| + + + | ++ + | ++ + | +
+ ++ + diff --git a/devtools/shared/discovery/discovery.js b/devtools/shared/discovery/discovery.js index eb3893138546..a07f21d445e7 100644 --- a/devtools/shared/discovery/discovery.js +++ b/devtools/shared/discovery/discovery.js @@ -137,22 +137,45 @@ Transport.prototype = { /** * Manages the local device's name. The name can be generated in serveral * platform-specific ways (see |_generate|). The aim is for each device on the - * same local network to have a unique name. + * same local network to have a unique name. If the Settings API is available, + * the name is saved there to persist across reboots. */ function LocalDevice() { this._name = LocalDevice.UNKNOWN; + if ("@mozilla.org/settingsService;1" in Cc) { + this._settings = + Cc["@mozilla.org/settingsService;1"].getService(Ci.nsISettingsService); + Services.obs.addObserver(this, "mozsettings-changed", false); + } // Trigger |_get| to load name eagerly this._get(); } +LocalDevice.SETTING = "devtools.discovery.device"; LocalDevice.UNKNOWN = "unknown"; LocalDevice.prototype = { _get: function () { - // Without Settings API, just generate a name and stop, since the value - // can't be persisted. - this._generate(); + if (!this._settings) { + // Without Settings API, just generate a name and stop, since the value + // can't be persisted. + this._generate(); + return; + } + // Initial read of setting value + this._settings.createLock().get(LocalDevice.SETTING, { + handle: (_, name) => { + if (name && name !== LocalDevice.UNKNOWN) { + this._name = name; + log("Device: " + this._name); + return; + } + // No existing name saved, so generate one. + this._generate(); + }, + handleError: () => log("Failed to get device name setting") + }); }, /** @@ -180,13 +203,39 @@ LocalDevice.prototype = { } }, + /** + * Observe any changes that might be made via the Settings app + */ + observe: function (subject, topic, data) { + if (topic !== "mozsettings-changed") { + return; + } + if ("wrappedJSObject" in subject) { + subject = subject.wrappedJSObject; + } + if (subject.key !== LocalDevice.SETTING) { + return; + } + this._name = subject.value; + log("Device: " + this._name); + }, + get name() { return this._name; }, set name(name) { - this._name = name; - log("Device: " + this._name); + if (!this._settings) { + this._name = name; + log("Device: " + this._name); + return; + } + // Persist to Settings API + // The new value will be seen and stored by the observer above + this._settings.createLock().set(LocalDevice.SETTING, name, { + handle: () => {}, + handleError: () => log("Failed to set device name setting") + }); } }; diff --git a/devtools/shared/fronts/settings.js b/devtools/shared/fronts/settings.js new file mode 100644 index 000000000000..158425364e55 --- /dev/null +++ b/devtools/shared/fronts/settings.js @@ -0,0 +1,29 @@ +/* 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 {settingsSpec} = require("devtools/shared/specs/settings"); +const protocol = require("devtools/shared/protocol"); + +const SettingsFront = protocol.FrontClassWithSpec(settingsSpec, { + initialize: function (client, form) { + protocol.Front.prototype.initialize.call(this, client); + this.actorID = form.settingsActor; + this.manage(this); + }, +}); + +const _knownSettingsFronts = new WeakMap(); + +exports.getSettingsFront = function (client, form) { + if (!form.settingsActor) { + return null; + } + if (_knownSettingsFronts.has(client)) { + return _knownSettingsFronts.get(client); + } + let front = new SettingsFront(client, form); + _knownSettingsFronts.set(client, front); + return front; +}; diff --git a/devtools/shared/specs/settings.js b/devtools/shared/specs/settings.js new file mode 100644 index 000000000000..482c8f473c06 --- /dev/null +++ b/devtools/shared/specs/settings.js @@ -0,0 +1,31 @@ +/* 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 {Arg, RetVal, generateActorSpec} = require("devtools/shared/protocol"); + +const settingsSpec = generateActorSpec({ + typeName: "settings", + + methods: { + getSetting: { + request: { value: Arg(0) }, + response: { value: RetVal("json") } + }, + setSetting: { + request: { name: Arg(0), value: Arg(1) }, + response: {} + }, + getAllSettings: { + request: {}, + response: { value: RetVal("json") } + }, + clearUserSetting: { + request: { name: Arg(0) }, + response: {} + } + }, +}); + +exports.settingsSpec = settingsSpec; diff --git a/dom/audiochannel/AudioChannelService.cpp b/dom/audiochannel/AudioChannelService.cpp index aa29228cdee2..8f964453b533 100644 --- a/dom/audiochannel/AudioChannelService.cpp +++ b/dom/audiochannel/AudioChannelService.cpp @@ -25,6 +25,7 @@ #include "nsGlobalWindow.h" #include "nsPIDOMWindow.h" #include "nsServiceManagerUtils.h" +#include "mozilla/dom/SettingChangeNotificationBinding.h" #ifdef MOZ_WIDGET_GONK #include "nsJSUtils.h" @@ -234,6 +235,11 @@ AudioChannelService::Shutdown() if (IsParentProcess()) { obs->RemoveObserver(gAudioChannelService, "ipc:content-shutdown"); + +#ifdef MOZ_WIDGET_GONK + // To monitor the volume settings based on audio channel. + obs->RemoveObserver(gAudioChannelService, "mozsettings-changed"); +#endif } } @@ -273,6 +279,11 @@ AudioChannelService::AudioChannelService() obs->AddObserver(this, "outer-window-destroyed", false); if (IsParentProcess()) { obs->AddObserver(this, "ipc:content-shutdown", false); + +#ifdef MOZ_WIDGET_GONK + // To monitor the volume settings based on audio channel. + obs->AddObserver(this, "mozsettings-changed", false); +#endif } } diff --git a/dom/events/moz.build b/dom/events/moz.build index 685837c25b37..329cfae0c870 100644 --- a/dom/events/moz.build +++ b/dom/events/moz.build @@ -139,6 +139,7 @@ LOCAL_INCLUDES += [ '/docshell/base', '/dom/base', '/dom/html', + '/dom/settings', '/dom/storage', '/dom/svg', '/dom/workers', diff --git a/dom/events/test/test_all_synthetic_events.html b/dom/events/test/test_all_synthetic_events.html index 6cf5a7123fca..c64d71778f21 100644 --- a/dom/events/test/test_all_synthetic_events.html +++ b/dom/events/test/test_all_synthetic_events.html @@ -259,6 +259,14 @@ const kEventConstructors = { return new MozOtaStatusEvent(aName, aProps); }, }, + MozSettingsEvent: { create: function (aName, aProps) { + return new MozSettingsEvent(aName, aProps); + }, + }, + MozSettingsTransactionEvent: { create: function (aName, aProps) { + return new MozSettingsTransactionEvent(aName, aProps); + }, + }, MozSmsEvent: { create: function (aName, aProps) { return new MozSmsEvent(aName, aProps); }, diff --git a/dom/media/tests/mochitest/NetworkPreparationChromeScript.js b/dom/media/tests/mochitest/NetworkPreparationChromeScript.js index 5d2a653d1dc3..1de778778c6b 100644 --- a/dom/media/tests/mochitest/NetworkPreparationChromeScript.js +++ b/dom/media/tests/mochitest/NetworkPreparationChromeScript.js @@ -8,6 +8,21 @@ var browser = Services.wm.getMostRecentWindow('navigator:browser'); var connection = browser.navigator.mozMobileConnections[0]; // provide a fake APN and enable data connection. +function enableDataConnection() { + let setLock = browser.navigator.mozSettings.createLock(); + setLock.set({ + 'ril.data.enabled': true, + 'ril.data.apnSettings': [ + [ + {'carrier':'T-Mobile US', + 'apn':'epc.tmobile.com', + 'mmsc':'http://mms.msg.eng.t-mobile.com/mms/wapenc', + 'types':['default','supl','mms']} + ] + ] + }); +} + // enable 3G radio function enableRadio() { if (connection.radioState !== 'enabled') { @@ -32,6 +47,7 @@ addMessageListener('prepare-network', function(message) { }); enableRadio(); + enableDataConnection(); }); addMessageListener('network-cleanup', function(message) { diff --git a/dom/moz.build b/dom/moz.build index c2b0311ef319..c558d717812d 100644 --- a/dom/moz.build +++ b/dom/moz.build @@ -12,6 +12,7 @@ interfaces = [ 'core', 'html', 'events', + 'settings', 'stylesheets', 'sidebar', 'css', @@ -66,6 +67,7 @@ DIRS += [ 'push', 'quota', 'security', + 'settings', 'storage', 'svg', 'time', diff --git a/dom/settings/SettingsDB.jsm b/dom/settings/SettingsDB.jsm new file mode 100644 index 000000000000..a1ea5e72b2c1 --- /dev/null +++ b/dom/settings/SettingsDB.jsm @@ -0,0 +1,249 @@ +/* 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"; + +var Cc = Components.classes; +var Ci = Components.interfaces; +var Cu = Components.utils; + +Cu.importGlobalProperties(['Blob', 'File']); +Cu.import("resource://gre/modules/Services.jsm"); + +this.EXPORTED_SYMBOLS = ["SettingsDB", "SETTINGSDB_NAME", "SETTINGSSTORE_NAME"]; + +var DEBUG = false; +var VERBOSE = false; + +try { + DEBUG = + Services.prefs.getBoolPref("dom.mozSettings.SettingsDB.debug.enabled"); + VERBOSE = + Services.prefs.getBoolPref("dom.mozSettings.SettingsDB.verbose.enabled"); +} catch (ex) { } + +function debug(s) { + dump("-*- SettingsDB: " + s + "\n"); +} + +const TYPED_ARRAY_THINGS = new Set([ + "Int8Array", + "Uint8Array", + "Uint8ClampedArray", + "Int16Array", + "Uint16Array", + "Int32Array", + "Uint32Array", + "Float32Array", + "Float64Array", +]); + +this.SETTINGSDB_NAME = "settings"; +this.SETTINGSDB_VERSION = 8; +this.SETTINGSSTORE_NAME = "settings"; + +Cu.import("resource://gre/modules/IndexedDBHelper.jsm"); +Cu.import("resource://gre/modules/FileUtils.jsm"); +Cu.import("resource://gre/modules/NetUtil.jsm"); + +this.SettingsDB = function SettingsDB() {} + +SettingsDB.prototype = { + + __proto__: IndexedDBHelper.prototype, + + upgradeSchema: function upgradeSchema(aTransaction, aDb, aOldVersion, aNewVersion) { + let objectStore; + if (aOldVersion == 0) { + objectStore = aDb.createObjectStore(SETTINGSSTORE_NAME, { keyPath: "settingName" }); + if (VERBOSE) debug("Created object stores"); + } else if (aOldVersion == 1) { + if (VERBOSE) debug("Get object store for upgrade and remove old index"); + objectStore = aTransaction.objectStore(SETTINGSSTORE_NAME); + objectStore.deleteIndex("settingValue"); + } else { + if (VERBOSE) debug("Get object store for upgrade"); + objectStore = aTransaction.objectStore(SETTINGSSTORE_NAME); + } + + // Loading resource://app/defaults/settings.json doesn't work because + // settings.json is not in the omnijar. + // So we look for the app dir instead and go from here... + let settingsFile = FileUtils.getFile("DefRt", ["settings.json"], false); + if (!settingsFile || (settingsFile && !settingsFile.exists())) { + // On b2g desktop builds the settings.json file is moved in the + // profile directory by the build system. + settingsFile = FileUtils.getFile("ProfD", ["settings.json"], false); + if (!settingsFile || (settingsFile && !settingsFile.exists())) { + return; + } + } + + let chan = NetUtil.newChannel({ + uri: NetUtil.newURI(settingsFile), + loadUsingSystemPrincipal: true}); + let stream = chan.open2(); + // Obtain a converter to read from a UTF-8 encoded input stream. + let converter = Cc["@mozilla.org/intl/scriptableunicodeconverter"] + .createInstance(Ci.nsIScriptableUnicodeConverter); + converter.charset = "UTF-8"; + let rawstr = converter.ConvertToUnicode(NetUtil.readInputStreamToString( + stream, + stream.available()) || ""); + let settings; + try { + settings = JSON.parse(rawstr); + } catch(e) { + if (DEBUG) debug("Error parsing " + settingsFile.path + " : " + e); + return; + } + stream.close(); + + objectStore.openCursor().onsuccess = function(event) { + let cursor = event.target.result; + if (cursor) { + let value = cursor.value; + if (value.settingName in settings) { + if (VERBOSE) debug("Upgrade " +settings[value.settingName]); + value.defaultValue = this.prepareValue(settings[value.settingName]); + delete settings[value.settingName]; + if ("settingValue" in value) { + value.userValue = this.prepareValue(value.settingValue); + delete value.settingValue; + } + cursor.update(value); + } else if ("userValue" in value || "settingValue" in value) { + value.defaultValue = undefined; + if (aOldVersion == 1 && value.settingValue) { + value.userValue = this.prepareValue(value.settingValue); + delete value.settingValue; + } + cursor.update(value); + } else { + cursor.delete(); + } + cursor.continue(); + } else { + for (let name in settings) { + let value = this.prepareValue(settings[name]); + if (VERBOSE) debug("Set new:" + name +", " + value); + objectStore.add({ settingName: name, defaultValue: value, userValue: undefined }); + } + } + }.bind(this); + }, + + // If the value is a data: uri, convert it to a Blob. + convertDataURIToBlob: function(aValue) { + /* base64 to ArrayBuffer decoding, from + https://developer.mozilla.org/en-US/docs/Web/JavaScript/Base64_encoding_and_decoding + */ + function b64ToUint6 (nChr) { + return nChr > 64 && nChr < 91 ? + nChr - 65 + : nChr > 96 && nChr < 123 ? + nChr - 71 + : nChr > 47 && nChr < 58 ? + nChr + 4 + : nChr === 43 ? + 62 + : nChr === 47 ? + 63 + : + 0; + } + + function base64DecToArr(sBase64, nBlocksSize) { + let sB64Enc = sBase64.replace(/[^A-Za-z0-9\+\/]/g, ""), + nInLen = sB64Enc.length, + nOutLen = nBlocksSize ? Math.ceil((nInLen * 3 + 1 >> 2) / nBlocksSize) * nBlocksSize + : nInLen * 3 + 1 >> 2, + taBytes = new Uint8Array(nOutLen); + + for (let nMod3, nMod4, nUint24 = 0, nOutIdx = 0, nInIdx = 0; nInIdx < nInLen; nInIdx++) { + nMod4 = nInIdx & 3; + nUint24 |= b64ToUint6(sB64Enc.charCodeAt(nInIdx)) << 18 - 6 * nMod4; + if (nMod4 === 3 || nInLen - nInIdx === 1) { + for (nMod3 = 0; nMod3 < 3 && nOutIdx < nOutLen; nMod3++, nOutIdx++) { + taBytes[nOutIdx] = nUint24 >>> (16 >>> nMod3 & 24) & 255; + } + nUint24 = 0; + } + } + return taBytes; + } + + // Check if we have a data: uri, and if it's base64 encoded. + // data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEA... + if (typeof aValue == "string" && aValue.startsWith("data:")) { + try { + let uri = Services.io.newURI(aValue); + // XXX: that would be nice to reuse the c++ bits of the data: + // protocol handler instead. + let mimeType = "application/octet-stream"; + let mimeDelim = aValue.indexOf(";"); + if (mimeDelim !== -1) { + mimeType = aValue.substring(5, mimeDelim); + } + let start = aValue.indexOf(",") + 1; + let isBase64 = ((aValue.indexOf("base64") + 7) == start); + let payload = aValue.substring(start); + + return new Blob([isBase64 ? base64DecToArr(payload) : payload], + { type: mimeType }); + } catch(e) { + dump(e); + } + } + return aValue + }, + + getObjectKind: function(aObject) { + if (aObject === null || aObject === undefined) { + return "primitive"; + } else if (Array.isArray(aObject)) { + return "array"; + } else if (aObject instanceof File) { + return "file"; + } else if (aObject instanceof Ci.nsIDOMBlob) { + return "blob"; + } else if (aObject.constructor.name == "Date") { + return "date"; + } else if (TYPED_ARRAY_THINGS.has(aObject.constructor.name)) { + return aObject.constructor.name; + } else if (typeof aObject == "object") { + return "object"; + } else { + return "primitive"; + } + }, + + // Makes sure any property that is a data: uri gets converted to a Blob. + prepareValue: function(aObject) { + let kind = this.getObjectKind(aObject); + if (kind == "array") { + let res = []; + aObject.forEach(function(aObj) { + res.push(this.prepareValue(aObj)); + }, this); + return res; + } else if (kind == "file" || kind == "blob" || kind == "date") { + return aObject; + } else if (kind == "primitive") { + return this.convertDataURIToBlob(aObject); + } + + // Fall-through, we now have a dictionary object. + let res = {}; + for (let prop in aObject) { + res[prop] = this.prepareValue(aObject[prop]); + } + return res; + }, + + init: function init() { + this.initDBHelper(SETTINGSDB_NAME, SETTINGSDB_VERSION, + [SETTINGSSTORE_NAME]); + } +} diff --git a/dom/settings/SettingsManager.js b/dom/settings/SettingsManager.js new file mode 100644 index 000000000000..a73e5f3127b8 --- /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 ? "
+ ++ + diff --git a/dom/settings/tests/test_settings_blobs.html b/dom/settings/tests/test_settings_blobs.html new file mode 100644 index 000000000000..6d24111cf8cc --- /dev/null +++ b/dom/settings/tests/test_settings_blobs.html @@ -0,0 +1,148 @@ + + + + +
+ ++ + diff --git a/dom/settings/tests/test_settings_bug1110872.html b/dom/settings/tests/test_settings_bug1110872.html new file mode 100644 index 000000000000..296c71a8c6f2 --- /dev/null +++ b/dom/settings/tests/test_settings_bug1110872.html @@ -0,0 +1,17 @@ + + + +
+ ++ + diff --git a/dom/settings/tests/test_settings_events.html b/dom/settings/tests/test_settings_events.html new file mode 100644 index 000000000000..a8bf851be309 --- /dev/null +++ b/dom/settings/tests/test_settings_events.html @@ -0,0 +1,47 @@ + + + + +
+ ++ + diff --git a/dom/settings/tests/test_settings_navigator_object.html b/dom/settings/tests/test_settings_navigator_object.html new file mode 100644 index 000000000000..2f666aee0844 --- /dev/null +++ b/dom/settings/tests/test_settings_navigator_object.html @@ -0,0 +1,37 @@ + + + + +
+ ++ + diff --git a/dom/settings/tests/test_settings_observer_killer.html b/dom/settings/tests/test_settings_observer_killer.html new file mode 100644 index 000000000000..8e7ed973c887 --- /dev/null +++ b/dom/settings/tests/test_settings_observer_killer.html @@ -0,0 +1,60 @@ + + + + +
+ ++ + diff --git a/dom/settings/tests/test_settings_onsettingchange.html b/dom/settings/tests/test_settings_onsettingchange.html new file mode 100644 index 000000000000..974da0c636bc --- /dev/null +++ b/dom/settings/tests/test_settings_onsettingchange.html @@ -0,0 +1,306 @@ + + + + +
+ ++ + diff --git a/dom/settings/tests/test_settings_permissions.html b/dom/settings/tests/test_settings_permissions.html new file mode 100644 index 000000000000..4cc02385aa51 --- /dev/null +++ b/dom/settings/tests/test_settings_permissions.html @@ -0,0 +1,184 @@ + + + + +
+ ++ + diff --git a/dom/settings/tests/test_settings_service.js b/dom/settings/tests/test_settings_service.js new file mode 100644 index 000000000000..132877a5d4b1 --- /dev/null +++ b/dom/settings/tests/test_settings_service.js @@ -0,0 +1,138 @@ +"use strict"; + +var Cu = Components.utils; +var Cc = Components.classes; +var Ci = Components.interfaces; + +if (SpecialPowers.isMainProcess()) { + SpecialPowers.Cu.import("resource://gre/modules/SettingsRequestManager.jsm"); +} + +Cu.import("resource://gre/modules/XPCOMUtils.jsm"); +Cu.import("resource://gre/modules/Services.jsm"); + +SimpleTest.waitForExplicitFinish(); + +XPCOMUtils.defineLazyServiceGetter(this, "SettingsService", + "@mozilla.org/settingsService;1", + "nsISettingsService"); + +var tests = [ + /* Callback tests */ + function() { + let callbackCount = 10; + + let callback = { + handle: function(name, result) { + switch (callbackCount) { + case 10: + case 9: + is(result, true, "result is true"); + break; + case 8: + case 7: + is(result, false, "result is false"); + break; + case 6: + case 5: + is(result, 9, "result is 9"); + break; + case 4: + case 3: + is(result, 9.4, "result is 9.4"); + break; + case 2: + is(result, false, "result is false"); + break; + case 1: + is(result, null, "result is null"); + break; + default: + ok(false, "Unexpected call: " + callbackCount); + } + + --callbackCount; + if (callbackCount === 0) { + next(); + } + }, + + handleError: function(name) { + ok(false, "error: " + name); + } + }; + + let lock = SettingsService.createLock(); + let lock1 = SettingsService.createLock(); + + lock.set("asdf", true, callback, null); + lock1.get("asdf", callback); + lock.get("asdf", callback); + lock.set("asdf", false, callback, null); + lock.get("asdf", callback); + lock.set("int", 9, callback, null); + lock.get("int", callback); + lock.set("doub", 9.4, callback, null); + lock.get("doub", callback); + lock1.get("asdfxxx", callback); + }, + + /* Observer tests */ + function() { + const MOZSETTINGS_CHANGED = "mozsettings-changed"; + const TEST_OBSERVER_KEY = "test.observer.key"; + const TEST_OBSERVER_VALUE = true; + const TEST_OBSERVER_MESSAGE = "test.observer.message"; + + var obs = { + observe: function (subject, topic, data) { + + if (topic !== MOZSETTINGS_CHANGED) { + ok(false, "Event is not mozsettings-changed."); + return; + } + // Data is now stored in subject + if ("wrappedJSObject" in subject) { + ok(true, "JS object wrapped into subject"); + subject = subject.wrappedJSObject; + } + if (subject["key"] != TEST_OBSERVER_KEY) { + return; + } + + function checkProp(name, type, value) { + ok(name in subject, "subject." + name + " is present"); + is(typeof subject[name], type, "subject." + name + " is " + type); + is(subject[name], value, "subject." + name + " is " + value); + } + + checkProp("key", "string", TEST_OBSERVER_KEY); + checkProp("value", "boolean", TEST_OBSERVER_VALUE); + checkProp("isInternalChange", "boolean", true); + + Services.obs.removeObserver(this, MOZSETTINGS_CHANGED); + next(); + } + }; + + Services.obs.addObserver(obs, MOZSETTINGS_CHANGED, false); + + let lock = SettingsService.createLock(); + lock.set(TEST_OBSERVER_KEY, TEST_OBSERVER_VALUE, null); + } +]; + +function next() { + let step = tests.shift(); + if (step) { + try { + step(); + } catch(e) { + ok(false, "Test threw: " + e); + } + } else { + SimpleTest.finish(); + } +} + +next(); diff --git a/dom/settings/tests/test_settings_service.xul b/dom/settings/tests/test_settings_service.xul new file mode 100644 index 000000000000..58a9efad96d2 --- /dev/null +++ b/dom/settings/tests/test_settings_service.xul @@ -0,0 +1,19 @@ + + + + +