The Tor Browser: comparison toolkit/components/social/SocialService.jsm

--1:000000000000
+:02a44b9bc5bd
+/* 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 = ["SocialService"];
+const { classes: Cc, interfaces: Ci, utils: Cu } = Components;
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+Cu.import("resource://gre/modules/AddonManager.jsm");
+Cu.import("resource://gre/modules/PlacesUtils.jsm");
+const URI_EXTENSION_STRINGS  = "chrome://mozapps/locale/extensions/extensions.properties";
+const ADDON_TYPE_SERVICE     = "service";
+const ID_SUFFIX              = "@services.mozilla.org";
+const STRING_TYPE_NAME       = "type.%ID%.name";
+XPCOMUtils.defineLazyModuleGetter(this, "getFrameWorkerHandle", "resource://gre/modules/FrameWorker.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "WorkerAPI", "resource://gre/modules/WorkerAPI.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "MozSocialAPI", "resource://gre/modules/MozSocialAPI.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "closeAllChatWindows", "resource://gre/modules/MozSocialAPI.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "DeferredTask", "resource://gre/modules/DeferredTask.jsm");
+XPCOMUtils.defineLazyServiceGetter(this, "etld",
+"@mozilla.org/network/effective-tld-service;1",
+"nsIEffectiveTLDService");
+/**
+* The SocialService is the public API to social providers - it tracks which
+* providers are installed and enabled, and is the entry-point for access to
+* the provider itself.
+*/
+// Internal helper methods and state
+let SocialServiceInternal = {
+get enabled() this.providerArray.length > 0,
+get providerArray() {
+return [p for ([, p] of Iterator(this.providers))];
+},
+get manifests() {
+// Retrieve the manifests of installed providers from prefs
+let MANIFEST_PREFS = Services.prefs.getBranch("social.manifest.");
+let prefs = MANIFEST_PREFS.getChildList("", []);
+for (let pref of prefs) {
+// we only consider manifests in user level prefs to be *installed*
+if (!MANIFEST_PREFS.prefHasUserValue(pref))
+continue;
+try {
+var manifest = JSON.parse(MANIFEST_PREFS.getComplexValue(pref, Ci.nsISupportsString).data);
+if (manifest && typeof(manifest) == "object" && manifest.origin)
+yield manifest;
+} catch (err) {
+Cu.reportError("SocialService: failed to load manifest: " + pref +
+", exception: " + err);
+}
+}
+},
+getManifestPrefname: function(origin) {
+// Retrieve the prefname for a given origin/manifest.
+// If no existing pref, return a generated prefname.
+let MANIFEST_PREFS = Services.prefs.getBranch("social.manifest.");
+let prefs = MANIFEST_PREFS.getChildList("", []);
+for (let pref of prefs) {
+try {
+var manifest = JSON.parse(MANIFEST_PREFS.getComplexValue(pref, Ci.nsISupportsString).data);
+if (manifest.origin == origin) {
+return pref;
+}
+} catch (err) {
+Cu.reportError("SocialService: failed to load manifest: " + pref +
+", exception: " + err);
+}
+}
+let originUri = Services.io.newURI(origin, null, null);
+return originUri.hostPort.replace('.','-');
+},
+orderedProviders: function(aCallback) {
+if (SocialServiceInternal.providerArray.length < 2) {
+schedule(function () {
+aCallback(SocialServiceInternal.providerArray);
+});
+return;
+}
+// query moz_hosts for frecency.  since some providers may not have a
+// frecency entry, we need to later sort on our own. We use the providers
+// object below as an easy way to later record the frecency on the provider
+// object from the query results.
+let hosts = [];
+let providers = {};
+for (let p of SocialServiceInternal.providerArray) {
+p.frecency = 0;
+providers[p.domain] = p;
+hosts.push(p.domain);
+};
+// cannot bind an array to stmt.params so we have to build the string
+let stmt = PlacesUtils.history.QueryInterface(Ci.nsPIPlacesDatabase)
+.DBConnection.createAsyncStatement(
+"SELECT host, frecency FROM moz_hosts WHERE host IN (" +
+[ '"' + host + '"' for each (host in hosts) ].join(",") + ") "
+);
+try {
+stmt.executeAsync({
+handleResult: function(aResultSet) {
+let row;
+while ((row = aResultSet.getNextRow())) {
+let rh = row.getResultByName("host");
+let frecency = row.getResultByName("frecency");
+providers[rh].frecency = parseInt(frecency) || 0;
+}
+},
+handleError: function(aError) {
+Cu.reportError(aError.message + " (Result = " + aError.result + ")");
+},
+handleCompletion: function(aReason) {
+// the query may not have returned all our providers, so we have
+// stamped the frecency on the provider and sort here. This makes sure
+// all enabled providers get sorted even with frecency zero.
+let providerList = SocialServiceInternal.providerArray;
+// reverse sort
+aCallback(providerList.sort(function(a, b) b.frecency - a.frecency));
+}
+});
+} finally {
+stmt.finalize();
+}
+}
+};
+XPCOMUtils.defineLazyGetter(SocialServiceInternal, "providers", function () {
+initService();
+let providers = {};
+for (let manifest of this.manifests) {
+try {
+if (ActiveProviders.has(manifest.origin)) {
+// enable the api when a provider is enabled
+MozSocialAPI.enabled = true;
+let provider = new SocialProvider(manifest);
+providers[provider.origin] = provider;
+}
+} catch (err) {
+Cu.reportError("SocialService: failed to load provider: " + manifest.origin +
+", exception: " + err);
+}
+}
+return providers;
+});
+function getOriginActivationType(origin) {
+let prefname = SocialServiceInternal.getManifestPrefname(origin);
+if (Services.prefs.getDefaultBranch("social.manifest.").getPrefType(prefname) == Services.prefs.PREF_STRING)
+return 'builtin';
+let whitelist = Services.prefs.getCharPref("social.whitelist").split(',');
+if (whitelist.indexOf(origin) >= 0)
+return 'whitelist';
+let directories = Services.prefs.getCharPref("social.directories").split(',');
+if (directories.indexOf(origin) >= 0)
+return 'directory';
+return 'foreign';
+}
+let ActiveProviders = {
+get _providers() {
+delete this._providers;
+this._providers = {};
+try {
+let pref = Services.prefs.getComplexValue("social.activeProviders",
+Ci.nsISupportsString);
+this._providers = JSON.parse(pref);
+} catch(ex) {}
+return this._providers;
+},
+has: function (origin) {
+return (origin in this._providers);
+},
+add: function (origin) {
+this._providers[origin] = 1;
+this._deferredTask.arm();
+},
+delete: function (origin) {
+delete this._providers[origin];
+this._deferredTask.arm();
+},
+flush: function () {
+this._deferredTask.disarm();
+this._persist();
+},
+get _deferredTask() {
+delete this._deferredTask;
+return this._deferredTask = new DeferredTask(this._persist.bind(this), 0);
+},
+_persist: function () {
+let string = Cc["@mozilla.org/supports-string;1"].
+createInstance(Ci.nsISupportsString);
+string.data = JSON.stringify(this._providers);
+Services.prefs.setComplexValue("social.activeProviders",
+Ci.nsISupportsString, string);
+}
+};
+function migrateSettings() {
+let activeProviders, enabled;
+try {
+activeProviders = Services.prefs.getCharPref("social.activeProviders");
+} catch(e) {
+// not set, we'll check if we need to migrate older prefs
+}
+if (Services.prefs.prefHasUserValue("social.enabled")) {
+enabled = Services.prefs.getBoolPref("social.enabled");
+}
+if (activeProviders) {
+// migration from fx21 to fx22 or later
+// ensure any *builtin* provider in activeproviders is in user level prefs
+for (let origin in ActiveProviders._providers) {
+let prefname;
+let manifest;
+let defaultManifest;
+try {
+prefname = getPrefnameFromOrigin(origin);
+manifest = JSON.parse(Services.prefs.getComplexValue(prefname, Ci.nsISupportsString).data);
+} catch(e) {
+// Our preference is missing or bad, remove from ActiveProviders and
+// continue. This is primarily an error-case and should only be
+// reached by either messing with preferences or hitting the one or
+// two days of nightly that ran into it, so we'll flush right away.
+ActiveProviders.delete(origin);
+ActiveProviders.flush();
+continue;
+}
+let needsUpdate = !manifest.updateDate;
+// fx23 may have built-ins with shareURL
+try {
+defaultManifest = Services.prefs.getDefaultBranch(null)
+.getComplexValue(prefname, Ci.nsISupportsString).data;
+defaultManifest = JSON.parse(defaultManifest);
+} catch(e) {
+// not a built-in, continue
+}
+if (defaultManifest) {
+if (defaultManifest.shareURL && !manifest.shareURL) {
+manifest.shareURL = defaultManifest.shareURL;
+needsUpdate = true;
+}
+if (defaultManifest.version && (!manifest.version || defaultManifest.version > manifest.version)) {
+manifest = defaultManifest;
+needsUpdate = true;
+}
+}
+if (needsUpdate) {
+// the provider was installed with an older build, so we will update the
+// timestamp and ensure the manifest is in user prefs
+delete manifest.builtin;
+// we're potentially updating for share, so always mark the updateDate
+manifest.updateDate = Date.now();
+if (!manifest.installDate)
+manifest.installDate = 0; // we don't know when it was installed
+let string = Cc["@mozilla.org/supports-string;1"].
+createInstance(Ci.nsISupportsString);
+string.data = JSON.stringify(manifest);
+Services.prefs.setComplexValue(prefname, Ci.nsISupportsString, string);
+}
+// as of fx 29, we no longer rely on social.enabled. migration from prior
+// versions should disable all service addons if social.enabled=false
+if (enabled === false) {
+ActiveProviders.delete(origin);
+}
+}
+ActiveProviders.flush();
+Services.prefs.clearUserPref("social.enabled");
+return;
+}
+// primary migration from pre-fx21
+let active;
+try {
+active = Services.prefs.getBoolPref("social.active");
+} catch(e) {}
+if (!active)
+return;
+// primary difference from SocialServiceInternal.manifests is that we
+// only read the default branch here.
+let manifestPrefs = Services.prefs.getDefaultBranch("social.manifest.");
+let prefs = manifestPrefs.getChildList("", []);
+for (let pref of prefs) {
+try {
+let manifest;
+try {
+manifest = JSON.parse(manifestPrefs.getComplexValue(pref, Ci.nsISupportsString).data);
+} catch(e) {
+// bad or missing preference, we wont update this one.
+continue;
+}
+if (manifest && typeof(manifest) == "object" && manifest.origin) {
+// our default manifests have been updated with the builtin flags as of
+// fx22, delete it so we can set the user-pref
+delete manifest.builtin;
+if (!manifest.updateDate) {
+manifest.updateDate = Date.now();
+manifest.installDate = 0; // we don't know when it was installed
+}
+let string = Cc["@mozilla.org/supports-string;1"].createInstance(Ci.nsISupportsString);
+string.data = JSON.stringify(manifest);
+// pref here is just the branch name, set the full pref name
+Services.prefs.setComplexValue("social.manifest." + pref, Ci.nsISupportsString, string);
+ActiveProviders.add(manifest.origin);
+ActiveProviders.flush();
+// social.active was used at a time that there was only one
+// builtin, we'll assume that is still the case
+return;
+}
+} catch (err) {
+Cu.reportError("SocialService: failed to load manifest: " + pref + ", exception: " + err);
+}
+}
+}
+function initService() {
+Services.obs.addObserver(function xpcomShutdown() {
+ActiveProviders.flush();
+SocialService._providerListeners = null;
+Services.obs.removeObserver(xpcomShutdown, "xpcom-shutdown");
+}, "xpcom-shutdown", false);
+try {
+migrateSettings();
+} catch(e) {
+// no matter what, if migration fails we do not want to render social
+// unusable. Worst case scenario is that, when upgrading Firefox, previously
+// enabled providers are not migrated.
+Cu.reportError("Error migrating social settings: " + e);
+}
+}
+function schedule(callback) {
+Services.tm.mainThread.dispatch(callback, Ci.nsIThread.DISPATCH_NORMAL);
+}
+// Public API
+this.SocialService = {
+get hasEnabledProviders() {
+// used as an optimization during startup, can be used to check if further
+// initialization should be done (e.g. creating the instances of
+// SocialProvider and turning on UI). ActiveProviders may have changed and
+// not yet flushed so we check the active providers array
+for (let p in ActiveProviders._providers) {
+return true;
+};
+return false;
+},
+get enabled() {
+return SocialServiceInternal.enabled;
+},
+set enabled(val) {
+throw new Error("not allowed to set SocialService.enabled");
+},
+// Adds and activates a builtin provider. The provider may or may not have
+// previously been added.  onDone is always called - with null if no such
+// provider exists, or the activated provider on success.
+addBuiltinProvider: function addBuiltinProvider(origin, onDone) {
+if (SocialServiceInternal.providers[origin]) {
+schedule(function() {
+onDone(SocialServiceInternal.providers[origin]);
+});
+return;
+}
+let manifest = SocialService.getManifestByOrigin(origin);
+if (manifest) {
+let addon = new AddonWrapper(manifest);
+AddonManagerPrivate.callAddonListeners("onEnabling", addon, false);
+addon.pendingOperations |= AddonManager.PENDING_ENABLE;
+this.addProvider(manifest, onDone);
+addon.pendingOperations -= AddonManager.PENDING_ENABLE;
+AddonManagerPrivate.callAddonListeners("onEnabled", addon);
+return;
+}
+schedule(function() {
+onDone(null);
+});
+},
+// Adds a provider given a manifest, and returns the added provider.
+addProvider: function addProvider(manifest, onDone) {
+if (SocialServiceInternal.providers[manifest.origin])
+throw new Error("SocialService.addProvider: provider with this origin already exists");
+// enable the api when a provider is enabled
+MozSocialAPI.enabled = true;
+let provider = new SocialProvider(manifest);
+SocialServiceInternal.providers[provider.origin] = provider;
+ActiveProviders.add(provider.origin);
+this.getOrderedProviderList(function (providers) {
+this._notifyProviderListeners("provider-enabled", provider.origin, providers);
+if (onDone)
+onDone(provider);
+}.bind(this));
+},
+// Removes a provider with the given origin, and notifies when the removal is
+// complete.
+removeProvider: function removeProvider(origin, onDone) {
+if (!(origin in SocialServiceInternal.providers))
+throw new Error("SocialService.removeProvider: no provider with origin " + origin + " exists!");
+let provider = SocialServiceInternal.providers[origin];
+let manifest = SocialService.getManifestByOrigin(origin);
+let addon = manifest && new AddonWrapper(manifest);
+if (addon) {
+AddonManagerPrivate.callAddonListeners("onDisabling", addon, false);
+addon.pendingOperations |= AddonManager.PENDING_DISABLE;
+}
+provider.enabled = false;
+ActiveProviders.delete(provider.origin);
+delete SocialServiceInternal.providers[origin];
+// disable the api if we have no enabled providers
+MozSocialAPI.enabled = SocialServiceInternal.enabled;
+if (addon) {
+// we have to do this now so the addon manager ui will update an uninstall
+// correctly.
+addon.pendingOperations -= AddonManager.PENDING_DISABLE;
+AddonManagerPrivate.callAddonListeners("onDisabled", addon);
+AddonManagerPrivate.notifyAddonChanged(addon.id, ADDON_TYPE_SERVICE, false);
+}
+this.getOrderedProviderList(function (providers) {
+this._notifyProviderListeners("provider-disabled", origin, providers);
+if (onDone)
+onDone();
+}.bind(this));
+},
+// Returns a single provider object with the specified origin.  The provider
+// must be "installed" (ie, in ActiveProviders)
+getProvider: function getProvider(origin, onDone) {
+schedule((function () {
+onDone(SocialServiceInternal.providers[origin] || null);
+}).bind(this));
+},
+// Returns an unordered array of installed providers
+getProviderList: function(onDone) {
+schedule(function () {
+onDone(SocialServiceInternal.providerArray);
+});
+},
+getManifestByOrigin: function(origin) {
+for (let manifest of SocialServiceInternal.manifests) {
+if (origin == manifest.origin) {
+return manifest;
+}
+}
+return null;
+},
+// Returns an array of installed providers, sorted by frecency
+getOrderedProviderList: function(onDone) {
+SocialServiceInternal.orderedProviders(onDone);
+},
+getOriginActivationType: function (origin) {
+return getOriginActivationType(origin);
+},
+_providerListeners: new Map(),
+registerProviderListener: function registerProviderListener(listener) {
+this._providerListeners.set(listener, 1);
+},
+unregisterProviderListener: function unregisterProviderListener(listener) {
+this._providerListeners.delete(listener);
+},
+_notifyProviderListeners: function (topic, origin, providers) {
+for (let [listener, ] of this._providerListeners) {
+try {
+listener(topic, origin, providers);
+} catch (ex) {
+Components.utils.reportError("SocialService: provider listener threw an exception: " + ex);
+}
+}
+},
+_manifestFromData: function(type, data, principal) {
+let featureURLs = ['workerURL', 'sidebarURL', 'shareURL', 'statusURL', 'markURL'];
+let resolveURLs = featureURLs.concat(['postActivationURL']);
+if (type == 'directory') {
+// directory provided manifests must have origin in manifest, use that
+if (!data['origin']) {
+Cu.reportError("SocialService.manifestFromData directory service provided manifest without origin.");
+return null;
+}
+let URI = Services.io.newURI(data.origin, null, null);
+principal = Services.scriptSecurityManager.getNoAppCodebasePrincipal(URI);
+}
+// force/fixup origin
+data.origin = principal.origin;
+// iconURL and name are required
+// iconURL may be a different origin (CDN or data url support) if this is
+// a whitelisted or directory listed provider
+let providerHasFeatures = [url for (url of featureURLs) if (data[url])].length > 0;
+if (!providerHasFeatures) {
+Cu.reportError("SocialService.manifestFromData manifest missing required urls.");
+return null;
+}
+if (!data['name'] || !data['iconURL']) {
+Cu.reportError("SocialService.manifestFromData manifest missing name or iconURL.");
+return null;
+}
+for (let url of resolveURLs) {
+if (data[url]) {
+try {
+let resolved = Services.io.newURI(principal.URI.resolve(data[url]), null, null);
+if (!(resolved.schemeIs("http") || resolved.schemeIs("https"))) {
+Cu.reportError("SocialService.manifestFromData unsupported scheme '" + resolved.scheme + "' for " + principal.origin);
+return null;
+}
+data[url] = resolved.spec;
+} catch(e) {
+Cu.reportError("SocialService.manifestFromData unable to resolve '" + url + "' for " + principal.origin);
+return null;
+}
+}
+}
+return data;
+},
+_getChromeWindow: function(aWindow) {
+var chromeWin = aWindow
+.QueryInterface(Ci.nsIInterfaceRequestor)
+.getInterface(Ci.nsIWebNavigation)
+.QueryInterface(Ci.nsIDocShellTreeItem)
+.rootTreeItem
+.QueryInterface(Ci.nsIInterfaceRequestor)
+.getInterface(Ci.nsIDOMWindow)
+.QueryInterface(Ci.nsIDOMChromeWindow);
+return chromeWin;
+},
+_showInstallNotification: function(aDOMDocument, aAddonInstaller) {
+let brandBundle = Services.strings.createBundle("chrome://branding/locale/brand.properties");
+let browserBundle = Services.strings.createBundle("chrome://browser/locale/browser.properties");
+let requestingWindow = aDOMDocument.defaultView.top;
+let chromeWin = this._getChromeWindow(requestingWindow).wrappedJSObject;
+let browser = chromeWin.gBrowser.getBrowserForDocument(aDOMDocument);
+let requestingURI =  Services.io.newURI(aDOMDocument.location.href, null, null);
+let productName = brandBundle.GetStringFromName("brandShortName");
+let message = browserBundle.formatStringFromName("service.install.description",
+[requestingURI.host, productName], 2);
+let action = {
+label: browserBundle.GetStringFromName("service.install.ok.label"),
+accessKey: browserBundle.GetStringFromName("service.install.ok.accesskey"),
+callback: function() {
+aAddonInstaller.install();
+},
+};
+let options = {
+learnMoreURL: Services.urlFormatter.formatURLPref("app.support.baseURL") + "social-api",
+};
+let anchor = "servicesInstall-notification-icon";
+let notificationid = "servicesInstall";
+chromeWin.PopupNotifications.show(browser, notificationid, message, anchor,
+action, [], options);
+},
+installProvider: function(aDOMDocument, data, installCallback) {
+let manifest;
+let installOrigin = aDOMDocument.nodePrincipal.origin;
+if (data) {
+let installType = getOriginActivationType(installOrigin);
+// if we get data, we MUST have a valid manifest generated from the data
+manifest = this._manifestFromData(installType, data, aDOMDocument.nodePrincipal);
+if (!manifest)
+throw new Error("SocialService.installProvider: service configuration is invalid from " + aDOMDocument.location.href);
+let addon = new AddonWrapper(manifest);
+if (addon && addon.blocklistState == Ci.nsIBlocklistService.STATE_BLOCKED)
+throw new Error("installProvider: provider with origin [" +
+installOrigin + "] is blocklisted");
+}
+let id = getAddonIDFromOrigin(installOrigin);
+AddonManager.getAddonByID(id, function(aAddon) {
+if (aAddon && aAddon.userDisabled) {
+aAddon.cancelUninstall();
+aAddon.userDisabled = false;
+}
+schedule(function () {
+this._installProvider(aDOMDocument, manifest, aManifest => {
+this._notifyProviderListeners("provider-installed", aManifest.origin);
+installCallback(aManifest);
+});
+}.bind(this));
+}.bind(this));
+},
+_installProvider: function(aDOMDocument, manifest, installCallback) {
+let sourceURI = aDOMDocument.location.href;
+let installOrigin = aDOMDocument.nodePrincipal.origin;
+let installType = getOriginActivationType(installOrigin);
+let installer;
+switch(installType) {
+case "foreign":
+if (!Services.prefs.getBoolPref("social.remote-install.enabled"))
+throw new Error("Remote install of services is disabled");
+if (!manifest)
+throw new Error("Cannot install provider without manifest data");
+installer = new AddonInstaller(sourceURI, manifest, installCallback);
+this._showInstallNotification(aDOMDocument, installer);
+break;
+case "builtin":
+// for builtin, we already have a manifest, but it can be overridden
+// we need to return the manifest in the installcallback, so fetch
+// it if we have it.  If there is no manifest data for the builtin,
+// the install request MUST be from the provider, otherwise we have
+// no way to know what provider we're trying to enable.  This is
+// primarily an issue for "version zero" providers that did not
+// send the manifest with the dom event for activation.
+if (!manifest) {
+let prefname = getPrefnameFromOrigin(installOrigin);
+manifest = Services.prefs.getDefaultBranch(null)
+.getComplexValue(prefname, Ci.nsISupportsString).data;
+manifest = JSON.parse(manifest);
+// ensure we override a builtin manifest by having a different value in it
+if (manifest.builtin)
+delete manifest.builtin;
+}
+case "directory":
+// a manifest is requried, and will have been vetted by reviewers
+case "whitelist":
+// a manifest is required, we'll catch a missing manifest below.
+if (!manifest)
+throw new Error("Cannot install provider without manifest data");
+installer = new AddonInstaller(sourceURI, manifest, installCallback);
+this._showInstallNotification(aDOMDocument, installer);
+break;
+default:
+throw new Error("SocialService.installProvider: Invalid install type "+installType+"\n");
+break;
+}
+},
+createWrapper: function(manifest) {
+return new AddonWrapper(manifest);
+},
+/**
+* updateProvider is used from the worker to self-update.  Since we do not
+* have knowledge of the currently selected provider here, we will notify
+* the front end to deal with any reload.
+*/
+updateProvider: function(aUpdateOrigin, aManifest) {
+let originUri = Services.io.newURI(aUpdateOrigin, null, null);
+let principal = Services.scriptSecurityManager.getNoAppCodebasePrincipal(originUri);
+let installType = this.getOriginActivationType(aUpdateOrigin);
+// if we get data, we MUST have a valid manifest generated from the data
+let manifest = this._manifestFromData(installType, aManifest, principal);
+if (!manifest)
+throw new Error("SocialService.installProvider: service configuration is invalid from " + aUpdateOrigin);
+// overwrite the preference
+let string = Cc["@mozilla.org/supports-string;1"].
+createInstance(Ci.nsISupportsString);
+string.data = JSON.stringify(manifest);
+Services.prefs.setComplexValue(getPrefnameFromOrigin(manifest.origin), Ci.nsISupportsString, string);
+// overwrite the existing provider then notify the front end so it can
+// handle any reload that might be necessary.
+if (ActiveProviders.has(manifest.origin)) {
+let provider = new SocialProvider(manifest);
+SocialServiceInternal.providers[provider.origin] = provider;
+// update the cache and ui, reload provider if necessary
+this.getOrderedProviderList(providers => {
+this._notifyProviderListeners("provider-update", provider.origin, providers);
+});
+}
+},
+uninstallProvider: function(origin, aCallback) {
+let manifest = SocialService.getManifestByOrigin(origin);
+let addon = new AddonWrapper(manifest);
+addon.uninstall(aCallback);
+}
+};
+/**
+* The SocialProvider object represents a social provider, and allows
+* access to its FrameWorker (if it has one).
+*
+* @constructor
+* @param {jsobj} object representing the manifest file describing this provider
+* @param {bool} boolean indicating whether this provider is "built in"
+*/
+function SocialProvider(input) {
+if (!input.name)
+throw new Error("SocialProvider must be passed a name");
+if (!input.origin)
+throw new Error("SocialProvider must be passed an origin");
+let addon = new AddonWrapper(input);
+if (addon.blocklistState == Ci.nsIBlocklistService.STATE_BLOCKED)
+throw new Error("SocialProvider: provider with origin [" +
+input.origin + "] is blocklisted");
+this.name = input.name;
+this.iconURL = input.iconURL;
+this.icon32URL = input.icon32URL;
+this.icon64URL = input.icon64URL;
+this.workerURL = input.workerURL;
+this.sidebarURL = input.sidebarURL;
+this.shareURL = input.shareURL;
+this.statusURL = input.statusURL;
+this.markURL = input.markURL;
+this.markedIcon = input.markedIcon;
+this.unmarkedIcon = input.unmarkedIcon;
+this.postActivationURL = input.postActivationURL;
+this.origin = input.origin;
+let originUri = Services.io.newURI(input.origin, null, null);
+this.principal = Services.scriptSecurityManager.getNoAppCodebasePrincipal(originUri);
+this.ambientNotificationIcons = {};
+this.errorState = null;
+this.frecency = 0;
+let activationType = getOriginActivationType(input.origin);
+this.blessed = activationType == "builtin" ||
+activationType == "whitelist";
+try {
+this.domain = etld.getBaseDomainFromHost(originUri.host);
+} catch(e) {
+this.domain = originUri.host;
+}
+}
+SocialProvider.prototype = {
+reload: function() {
+this._terminate();
+this._activate();
+Services.obs.notifyObservers(null, "social:provider-reload", this.origin);
+},
+// Provider enabled/disabled state. Disabled providers do not have active
+// connections to their FrameWorkers.
+_enabled: false,
+get enabled() {
+return this._enabled;
+},
+set enabled(val) {
+let enable = !!val;
+if (enable == this._enabled)
+return;
+this._enabled = enable;
+if (enable) {
+this._activate();
+} else {
+this._terminate();
+}
+},
+get manifest() {
+return SocialService.getManifestByOrigin(this.origin);
+},
+// Reference to a workerAPI object for this provider. Null if the provider has
+// no FrameWorker, or is disabled.
+workerAPI: null,
+// Contains information related to the user's profile. Populated by the
+// workerAPI via updateUserProfile.
+// Properties:
+//   iconURL, portrait, userName, displayName, profileURL
+// See https://github.com/mozilla/socialapi-dev/blob/develop/docs/socialAPI.md
+// A value of null or an empty object means 'user not logged in'.
+// A value of undefined means the service has not yet told us the status of
+// the profile (ie, the service is still loading/initing, or the provider has
+// no FrameWorker)
+// This distinction might be used to cache certain data between runs - eg,
+// browser-social.js caches the notification icons so they can be displayed
+// quickly at startup without waiting for the provider to initialize -
+// 'undefined' means 'ok to use cached values' versus 'null' meaning 'cached
+// values aren't to be used as the user is logged out'.
+profile: undefined,
+// Map of objects describing the provider's notification icons, whose
+// properties include:
+//   name, iconURL, counter, contentPanel
+// See https://developer.mozilla.org/en-US/docs/Social_API
+ambientNotificationIcons: null,
+// Called by the workerAPI to update our profile information.
+updateUserProfile: function(profile) {
+if (!profile)
+profile = {};
+let accountChanged = !this.profile || this.profile.userName != profile.userName;
+this.profile = profile;
+// Sanitize the portrait from any potential script-injection.
+if (profile.portrait) {
+try {
+let portraitUri = Services.io.newURI(profile.portrait, null, null);
+let scheme = portraitUri ? portraitUri.scheme : "";
+if (scheme != "data" && scheme != "http" && scheme != "https") {
+profile.portrait = "";
+}
+} catch (ex) {
+profile.portrait = "";
+}
+}
+if (profile.iconURL)
+this.iconURL = profile.iconURL;
+if (!profile.displayName)
+profile.displayName = profile.userName;
+// if no userName, consider this a logged out state, emtpy the
+// users ambient notifications.  notify both profile and ambient
+// changes to clear everything
+if (!profile.userName) {
+this.profile = {};
+this.ambientNotificationIcons = {};
+Services.obs.notifyObservers(null, "social:ambient-notification-changed", this.origin);
+}
+Services.obs.notifyObservers(null, "social:profile-changed", this.origin);
+if (accountChanged)
+closeAllChatWindows(this);
+},
+haveLoggedInUser: function () {
+return !!(this.profile && this.profile.userName);
+},
+// Called by the workerAPI to add/update a notification icon.
+setAmbientNotification: function(notification) {
+if (!this.profile.userName)
+throw new Error("unable to set notifications while logged out");
+if (!this.ambientNotificationIcons[notification.name] &&
+Object.keys(this.ambientNotificationIcons).length >= 3) {
+throw new Error("ambient notification limit reached");
+}
+this.ambientNotificationIcons[notification.name] = notification;
+Services.obs.notifyObservers(null, "social:ambient-notification-changed", this.origin);
+},
+// Internal helper methods
+_activate: function _activate() {
+// Initialize the workerAPI and its port first, so that its initialization
+// occurs before any other messages are processed by other ports.
+let workerAPIPort = this.getWorkerPort();
+if (workerAPIPort)
+this.workerAPI = new WorkerAPI(this, workerAPIPort);
+},
+_terminate: function _terminate() {
+closeAllChatWindows(this);
+if (this.workerURL) {
+try {
+getFrameWorkerHandle(this.workerURL).terminate();
+} catch (e) {
+Cu.reportError("SocialProvider FrameWorker termination failed: " + e);
+}
+}
+if (this.workerAPI) {
+this.workerAPI.terminate();
+}
+this.errorState = null;
+this.workerAPI = null;
+this.profile = undefined;
+},
+/**
+* Instantiates a FrameWorker for the provider if one doesn't exist, and
+* returns a reference to a new port to that FrameWorker.
+*
+* Returns null if this provider has no workerURL, or is disabled.
+*
+* @param {DOMWindow} window (optional)
+*/
+getWorkerPort: function getWorkerPort(window) {
+if (!this.workerURL || !this.enabled)
+return null;
+// Only allow localStorage in the frameworker for blessed providers
+let allowLocalStorage = this.blessed;
+let handle = getFrameWorkerHandle(this.workerURL, window,
+"SocialProvider:" + this.origin, this.origin,
+allowLocalStorage);
+return handle.port;
+},
+/**
+* Checks if a given URI is of the same origin as the provider.
+*
+* Returns true or false.
+*
+* @param {URI or string} uri
+*/
+isSameOrigin: function isSameOrigin(uri, allowIfInheritsPrincipal) {
+if (!uri)
+return false;
+if (typeof uri == "string") {
+try {
+uri = Services.io.newURI(uri, null, null);
+} catch (ex) {
+// an invalid URL can't be loaded!
+return false;
+}
+}
+try {
+this.principal.checkMayLoad(
+uri, // the thing to check.
+false, // reportError - we do our own reporting when necessary.
+allowIfInheritsPrincipal
+);
+return true;
+} catch (ex) {
+return false;
+}
+},
+/**
+* Resolve partial URLs for a provider.
+*
+* Returns nsIURI object or null on failure
+*
+* @param {string} url
+*/
+resolveUri: function resolveUri(url) {
+try {
+let fullURL = this.principal.URI.resolve(url);
+return Services.io.newURI(fullURL, null, null);
+} catch (ex) {
+Cu.reportError("mozSocial: failed to resolve window URL: " + url + "; " + ex);
+return null;
+}
+}
+}
+function getAddonIDFromOrigin(origin) {
+let originUri = Services.io.newURI(origin, null, null);
+return originUri.host + ID_SUFFIX;
+}
+function getPrefnameFromOrigin(origin) {
+return "social.manifest." + SocialServiceInternal.getManifestPrefname(origin);
+}
+function AddonInstaller(sourceURI, aManifest, installCallback) {
+aManifest.updateDate = Date.now();
+// get the existing manifest for installDate
+let manifest = SocialService.getManifestByOrigin(aManifest.origin);
+let isNewInstall = !manifest;
+if (manifest && manifest.installDate)
+aManifest.installDate = manifest.installDate;
+else
+aManifest.installDate = aManifest.updateDate;
+this.sourceURI = sourceURI;
+this.install = function() {
+let addon = this.addon;
+if (isNewInstall) {
+AddonManagerPrivate.callInstallListeners("onExternalInstall", null, addon, null, false);
+AddonManagerPrivate.callAddonListeners("onInstalling", addon, false);
+}
+let string = Cc["@mozilla.org/supports-string;1"].
+createInstance(Ci.nsISupportsString);
+string.data = JSON.stringify(aManifest);
+Services.prefs.setComplexValue(getPrefnameFromOrigin(aManifest.origin), Ci.nsISupportsString, string);
+if (isNewInstall) {
+AddonManagerPrivate.callAddonListeners("onInstalled", addon);
+}
+installCallback(aManifest);
+};
+this.cancel = function() {
+Services.prefs.clearUserPref(getPrefnameFromOrigin(aManifest.origin))
+},
+this.addon = new AddonWrapper(aManifest);
+};
+var SocialAddonProvider = {
+startup: function() {},
+shutdown: function() {},
+updateAddonAppDisabledStates: function() {
+// we wont bother with "enabling" services that are released from blocklist
+for (let manifest of SocialServiceInternal.manifests) {
+try {
+if (ActiveProviders.has(manifest.origin)) {
+let addon = new AddonWrapper(manifest);
+if (addon.blocklistState != Ci.nsIBlocklistService.STATE_NOT_BLOCKED) {
+SocialService.removeProvider(manifest.origin);
+}
+}
+} catch(e) {
+Cu.reportError(e);
+}
+}
+},
+getAddonByID: function(aId, aCallback) {
+for (let manifest of SocialServiceInternal.manifests) {
+if (aId == getAddonIDFromOrigin(manifest.origin)) {
+aCallback(new AddonWrapper(manifest));
+return;
+}
+}
+aCallback(null);
+},
+getAddonsByTypes: function(aTypes, aCallback) {
+if (aTypes && aTypes.indexOf(ADDON_TYPE_SERVICE) == -1) {
+aCallback([]);
+return;
+}
+aCallback([new AddonWrapper(a) for each (a in SocialServiceInternal.manifests)]);
+},
+removeAddon: function(aAddon, aCallback) {
+AddonManagerPrivate.callAddonListeners("onUninstalling", aAddon, false);
+aAddon.pendingOperations |= AddonManager.PENDING_UNINSTALL;
+Services.prefs.clearUserPref(getPrefnameFromOrigin(aAddon.manifest.origin));
+aAddon.pendingOperations -= AddonManager.PENDING_UNINSTALL;
+AddonManagerPrivate.callAddonListeners("onUninstalled", aAddon);
+SocialService._notifyProviderListeners("provider-uninstalled", aAddon.manifest.origin);
+if (aCallback)
+schedule(aCallback);
+}
+}
+function AddonWrapper(aManifest) {
+this.manifest = aManifest;
+this.id = getAddonIDFromOrigin(this.manifest.origin);
+this._pending = AddonManager.PENDING_NONE;
+}
+AddonWrapper.prototype = {
+get type() {
+return ADDON_TYPE_SERVICE;
+},
+get appDisabled() {
+return this.blocklistState == Ci.nsIBlocklistService.STATE_BLOCKED;
+},
+set softDisabled(val) {
+this.userDisabled = val;
+},
+get softDisabled() {
+return this.userDisabled;
+},
+get isCompatible() {
+return true;
+},
+get isPlatformCompatible() {
+return true;
+},
+get scope() {
+return AddonManager.SCOPE_PROFILE;
+},
+get foreignInstall() {
+return false;
+},
+isCompatibleWith: function(appVersion, platformVersion) {
+return true;
+},
+get providesUpdatesSecurely() {
+return true;
+},
+get blocklistState() {
+return Services.blocklist.getAddonBlocklistState(this);
+},
+get blocklistURL() {
+return Services.blocklist.getAddonBlocklistURL(this);
+},
+get screenshots() {
+return [];
+},
+get pendingOperations() {
+return this._pending || AddonManager.PENDING_NONE;
+},
+set pendingOperations(val) {
+this._pending = val;
+},
+get operationsRequiringRestart() {
+return AddonManager.OP_NEEDS_RESTART_NONE;
+},
+get size() {
+return null;
+},
+get permissions() {
+let permissions = 0;
+// any "user defined" manifest can be removed
+if (Services.prefs.prefHasUserValue(getPrefnameFromOrigin(this.manifest.origin)))
+permissions = AddonManager.PERM_CAN_UNINSTALL;
+if (!this.appDisabled) {
+if (this.userDisabled) {
+permissions |= AddonManager.PERM_CAN_ENABLE;
+} else {
+permissions |= AddonManager.PERM_CAN_DISABLE;
+}
+}
+return permissions;
+},
+findUpdates: function(listener, reason, appVersion, platformVersion) {
+if ("onNoCompatibilityUpdateAvailable" in listener)
+listener.onNoCompatibilityUpdateAvailable(this);
+if ("onNoUpdateAvailable" in listener)
+listener.onNoUpdateAvailable(this);
+if ("onUpdateFinished" in listener)
+listener.onUpdateFinished(this);
+},
+get isActive() {
+return ActiveProviders.has(this.manifest.origin);
+},
+get name() {
+return this.manifest.name;
+},
+get version() {
+return this.manifest.version ? this.manifest.version : "";
+},
+get iconURL() {
+return this.manifest.icon32URL ? this.manifest.icon32URL : this.manifest.iconURL;
+},
+get icon64URL() {
+return this.manifest.icon64URL;
+},
+get icons() {
+let icons = {
+16: this.manifest.iconURL
+};
+if (this.manifest.icon32URL)
+icons[32] = this.manifest.icon32URL;
+if (this.manifest.icon64URL)
+icons[64] = this.manifest.icon64URL;
+return icons;
+},
+get description() {
+return this.manifest.description;
+},
+get homepageURL() {
+return this.manifest.homepageURL;
+},
+get defaultLocale() {
+return this.manifest.defaultLocale;
+},
+get selectedLocale() {
+return this.manifest.selectedLocale;
+},
+get installDate() {
+return this.manifest.installDate ? new Date(this.manifest.installDate) : null;
+},
+get updateDate() {
+return this.manifest.updateDate ? new Date(this.manifest.updateDate) : null;
+},
+get creator() {
+return new AddonManagerPrivate.AddonAuthor(this.manifest.author);
+},
+get userDisabled() {
+return this.appDisabled || !ActiveProviders.has(this.manifest.origin);
+},
+set userDisabled(val) {
+if (val == this.userDisabled)
+return val;
+if (val) {
+SocialService.removeProvider(this.manifest.origin);
+} else if (!this.appDisabled) {
+SocialService.addBuiltinProvider(this.manifest.origin);
+}
+return val;
+},
+uninstall: function(aCallback) {
+let prefName = getPrefnameFromOrigin(this.manifest.origin);
+if (Services.prefs.prefHasUserValue(prefName)) {
+if (ActiveProviders.has(this.manifest.origin)) {
+SocialService.removeProvider(this.manifest.origin, function() {
+SocialAddonProvider.removeAddon(this, aCallback);
+}.bind(this));
+} else {
+SocialAddonProvider.removeAddon(this, aCallback);
+}
+} else {
+schedule(aCallback);
+}
+},
+cancelUninstall: function() {
+this._pending -= AddonManager.PENDING_UNINSTALL;
+AddonManagerPrivate.callAddonListeners("onOperationCancelled", this);
+}
+};
+AddonManagerPrivate.registerProvider(SocialAddonProvider, [
+new AddonManagerPrivate.AddonType(ADDON_TYPE_SERVICE, URI_EXTENSION_STRINGS,
+STRING_TYPE_NAME,
+AddonManager.VIEW_TYPE_LIST, 10000)
+]);

The Tor Browser / file comparison

comparison: toolkit/components/social/SocialService.jsm

toolkit/components/social/SocialService.jsm