The Tor Browser: comparison services/sync/modules/engines/prefs.js

comparison: services/sync/modules/engines/prefs.js

services/sync/modules/engines/prefs.js

branch: TOR_BUG_9701
changeset 15: b8a032363ba2

equal deleted inserted replaced

--1:000000000000
+:71f7a775c480
+/* 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/. */
+this.EXPORTED_SYMBOLS = ['PrefsEngine', 'PrefRec'];
+const Cc = Components.classes;
+const Ci = Components.interfaces;
+const Cu = Components.utils;
+const WEAVE_SYNC_PREFS = "services.sync.prefs.sync.";
+Cu.import("resource://services-sync/engines.js");
+Cu.import("resource://services-sync/record.js");
+Cu.import("resource://services-sync/util.js");
+Cu.import("resource://services-sync/constants.js");
+Cu.import("resource://services-common/utils.js");
+Cu.import("resource://gre/modules/LightweightThemeManager.jsm");
+Cu.import("resource://gre/modules/Preferences.jsm");
+const PREFS_GUID = CommonUtils.encodeBase64URL(Services.appinfo.ID);
+this.PrefRec = function PrefRec(collection, id) {
+CryptoWrapper.call(this, collection, id);
+}
+PrefRec.prototype = {
+__proto__: CryptoWrapper.prototype,
+_logName: "Sync.Record.Pref",
+};
+Utils.deferGetSet(PrefRec, "cleartext", ["value"]);
+this.PrefsEngine = function PrefsEngine(service) {
+SyncEngine.call(this, "Prefs", service);
+}
+PrefsEngine.prototype = {
+__proto__: SyncEngine.prototype,
+_storeObj: PrefStore,
+_trackerObj: PrefTracker,
+_recordObj: PrefRec,
+version: 2,
+getChangedIDs: function getChangedIDs() {
+// No need for a proper timestamp (no conflict resolution needed).
+let changedIDs = {};
+if (this._tracker.modified)
+changedIDs[PREFS_GUID] = 0;
+return changedIDs;
+},
+_wipeClient: function _wipeClient() {
+SyncEngine.prototype._wipeClient.call(this);
+this.justWiped = true;
+},
+_reconcile: function _reconcile(item) {
+// Apply the incoming item if we don't care about the local data
+if (this.justWiped) {
+this.justWiped = false;
+return true;
+}
+return SyncEngine.prototype._reconcile.call(this, item);
+}
+};
+function PrefStore(name, engine) {
+Store.call(this, name, engine);
+Svc.Obs.add("profile-before-change", function () {
+this.__prefs = null;
+}, this);
+}
+PrefStore.prototype = {
+__proto__: Store.prototype,
+__prefs: null,
+get _prefs() {
+if (!this.__prefs)
+this.__prefs = new Preferences();
+return this.__prefs;
+},
+_getSyncPrefs: function _getSyncPrefs() {
+let syncPrefs = Cc["@mozilla.org/preferences-service;1"]
+.getService(Ci.nsIPrefService)
+.getBranch(WEAVE_SYNC_PREFS)
+.getChildList("", {});
+// Also sync preferences that determine which prefs get synced.
+return syncPrefs.concat(
+syncPrefs.map(function (pref) { return WEAVE_SYNC_PREFS + pref; }));
+},
+_isSynced: function _isSyncedPref(pref) {
+return (pref.indexOf(WEAVE_SYNC_PREFS) == 0)
+|| this._prefs.get(WEAVE_SYNC_PREFS + pref, false);
+},
+_getAllPrefs: function () {
+let values = {};
+for each (let pref in this._getSyncPrefs()) {
+if (this._isSynced(pref)) {
+// Missing prefs get the null value.
+values[pref] = this._prefs.get(pref, null);
+}
+}
+return values;
+},
+_setAllPrefs: function PrefStore__setAllPrefs(values) {
+let enabledPref = "lightweightThemes.isThemeSelected";
+let enabledBefore = this._prefs.get(enabledPref, false);
+let prevTheme = LightweightThemeManager.currentTheme;
+for (let [pref, value] in Iterator(values)) {
+if (!this._isSynced(pref))
+continue;
+// Pref has gone missing, best we can do is reset it.
+if (value == null) {
+this._prefs.reset(pref);
+continue;
+}
+try {
+this._prefs.set(pref, value);
+} catch(ex) {
+this._log.trace("Failed to set pref: " + pref + ": " + ex);
+}
+}
+// Notify the lightweight theme manager of all the new values
+let enabledNow = this._prefs.get(enabledPref, false);
+if (enabledBefore && !enabledNow) {
+LightweightThemeManager.currentTheme = null;
+} else if (enabledNow && LightweightThemeManager.usedThemes[0] != prevTheme) {
+LightweightThemeManager.currentTheme = null;
+LightweightThemeManager.currentTheme = LightweightThemeManager.usedThemes[0];
+}
+},
+getAllIDs: function PrefStore_getAllIDs() {
+/* We store all prefs in just one WBO, with just one GUID */
+let allprefs = {};
+allprefs[PREFS_GUID] = true;
+return allprefs;
+},
+changeItemID: function PrefStore_changeItemID(oldID, newID) {
+this._log.trace("PrefStore GUID is constant!");
+},
+itemExists: function FormStore_itemExists(id) {
+return (id === PREFS_GUID);
+},
+createRecord: function createRecord(id, collection) {
+let record = new PrefRec(collection, id);
+if (id == PREFS_GUID) {
+record.value = this._getAllPrefs();
+} else {
+record.deleted = true;
+}
+return record;
+},
+create: function PrefStore_create(record) {
+this._log.trace("Ignoring create request");
+},
+remove: function PrefStore_remove(record) {
+this._log.trace("Ignoring remove request");
+},
+update: function PrefStore_update(record) {
+// Silently ignore pref updates that are for other apps.
+if (record.id != PREFS_GUID)
+return;
+this._log.trace("Received pref updates, applying...");
+this._setAllPrefs(record.value);
+},
+wipe: function PrefStore_wipe() {
+this._log.trace("Ignoring wipe request");
+}
+};
+function PrefTracker(name, engine) {
+Tracker.call(this, name, engine);
+Svc.Obs.add("profile-before-change", this);
+Svc.Obs.add("weave:engine:start-tracking", this);
+Svc.Obs.add("weave:engine:stop-tracking", this);
+}
+PrefTracker.prototype = {
+__proto__: Tracker.prototype,
+get modified() {
+return Svc.Prefs.get("engine.prefs.modified", false);
+},
+set modified(value) {
+Svc.Prefs.set("engine.prefs.modified", value);
+},
+loadChangedIDs: function loadChangedIDs() {
+// Don't read changed IDs from disk at start up.
+},
+clearChangedIDs: function clearChangedIDs() {
+this.modified = false;
+},
+__prefs: null,
+get _prefs() {
+if (!this.__prefs) {
+this.__prefs = new Preferences();
+}
+return this.__prefs;
+},
+startTracking: function () {
+Services.prefs.addObserver("", this, false);
+},
+stopTracking: function () {
+this.__prefs = null;
+Services.prefs.removeObserver("", this);
+},
+observe: function (subject, topic, data) {
+Tracker.prototype.observe.call(this, subject, topic, data);
+switch (topic) {
+case "profile-before-change":
+this.stopTracking();
+break;
+case "nsPref:changed":
+// Trigger a sync for MULTI-DEVICE for a change that determines
+// which prefs are synced or a regular pref change.
+if (data.indexOf(WEAVE_SYNC_PREFS) == 0 ||
+this._prefs.get(WEAVE_SYNC_PREFS + data, false)) {
+this.score += SCORE_INCREMENT_XLARGE;
+this.modified = true;
+this._log.trace("Preference " + data + " changed");
+}
+break;
+}
+}
+};