SocialService.jsm
/* 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);
},
getPageSize: function(name) {
let manifest = this.manifest;
if (manifest && manifest.pageSize)
return manifest.pageSize[name];
return undefined;
},
// 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)
]);
