mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-12-08 05:52:32 +00:00
5758dc5c47
As with bug 834936, this is meant to be temporary until zones land and we have decent JSM overhead levels.
155 lines
5.4 KiB
JavaScript
155 lines
5.4 KiB
JavaScript
/* 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/. */
|
|
|
|
#ifndef MERGED_COMPARTMENT
|
|
|
|
this.EXPORTED_SYMBOLS = ["Observers"];
|
|
|
|
const Cc = Components.classes;
|
|
const Ci = Components.interfaces;
|
|
const Cr = Components.results;
|
|
const Cu = Components.utils;
|
|
|
|
#endif
|
|
|
|
Cu.import("resource://gre/modules/XPCOMUtils.jsm");
|
|
|
|
/**
|
|
* A service for adding, removing and notifying observers of notifications.
|
|
* Wraps the nsIObserverService interface.
|
|
*
|
|
* @version 0.2
|
|
*/
|
|
this.Observers = {
|
|
/**
|
|
* Register the given callback as an observer of the given topic.
|
|
*
|
|
* @param topic {String}
|
|
* the topic to observe
|
|
*
|
|
* @param callback {Object}
|
|
* the callback; an Object that implements nsIObserver or a Function
|
|
* that gets called when the notification occurs
|
|
*
|
|
* @param thisObject {Object} [optional]
|
|
* the object to use as |this| when calling a Function callback
|
|
*
|
|
* @returns the observer
|
|
*/
|
|
add: function(topic, callback, thisObject) {
|
|
let observer = new Observer(topic, callback, thisObject);
|
|
this._cache.push(observer);
|
|
this._service.addObserver(observer, topic, true);
|
|
|
|
return observer;
|
|
},
|
|
|
|
/**
|
|
* Unregister the given callback as an observer of the given topic.
|
|
*
|
|
* @param topic {String}
|
|
* the topic being observed
|
|
*
|
|
* @param callback {Object}
|
|
* the callback doing the observing
|
|
*
|
|
* @param thisObject {Object} [optional]
|
|
* the object being used as |this| when calling a Function callback
|
|
*/
|
|
remove: function(topic, callback, thisObject) {
|
|
// This seems fairly inefficient, but I'm not sure how much better
|
|
// we can make it. We could index by topic, but we can't index by callback
|
|
// or thisObject, as far as I know, since the keys to JavaScript hashes
|
|
// (a.k.a. objects) can apparently only be primitive values.
|
|
let [observer] = this._cache.filter(function(v) v.topic == topic &&
|
|
v.callback == callback &&
|
|
v.thisObject == thisObject);
|
|
if (observer) {
|
|
this._service.removeObserver(observer, topic);
|
|
this._cache.splice(this._cache.indexOf(observer), 1);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Notify observers about something.
|
|
*
|
|
* @param topic {String}
|
|
* the topic to notify observers about
|
|
*
|
|
* @param subject {Object} [optional]
|
|
* some information about the topic; can be any JS object or primitive
|
|
*
|
|
* @param data {String} [optional] [deprecated]
|
|
* some more information about the topic; deprecated as the subject
|
|
* is sufficient to pass all needed information to the JS observers
|
|
* that this module targets; if you have multiple values to pass to
|
|
* the observer, wrap them in an object and pass them via the subject
|
|
* parameter (i.e.: { foo: 1, bar: "some string", baz: myObject })
|
|
*/
|
|
notify: function(topic, subject, data) {
|
|
subject = (typeof subject == "undefined") ? null : new Subject(subject);
|
|
data = (typeof data == "undefined") ? null : data;
|
|
this._service.notifyObservers(subject, topic, data);
|
|
},
|
|
|
|
_service: Cc["@mozilla.org/observer-service;1"].
|
|
getService(Ci.nsIObserverService),
|
|
|
|
/**
|
|
* A cache of observers that have been added.
|
|
*
|
|
* We use this to remove observers when a caller calls |remove|.
|
|
*
|
|
* XXX This might result in reference cycles, causing memory leaks,
|
|
* if we hold a reference to an observer that holds a reference to us.
|
|
* Could we fix that by making this an independent top-level object
|
|
* rather than a property of this object?
|
|
*/
|
|
_cache: []
|
|
};
|
|
|
|
|
|
function Observer(topic, callback, thisObject) {
|
|
this.topic = topic;
|
|
this.callback = callback;
|
|
this.thisObject = thisObject;
|
|
}
|
|
|
|
Observer.prototype = {
|
|
QueryInterface: XPCOMUtils.generateQI([Ci.nsIObserver, Ci.nsISupportsWeakReference]),
|
|
observe: function(subject, topic, data) {
|
|
// Extract the wrapped object for subjects that are one of our wrappers
|
|
// around a JS object. This way we support both wrapped subjects created
|
|
// using this module and those that are real XPCOM components.
|
|
if (subject && typeof subject == "object" &&
|
|
("wrappedJSObject" in subject) &&
|
|
("observersModuleSubjectWrapper" in subject.wrappedJSObject))
|
|
subject = subject.wrappedJSObject.object;
|
|
|
|
if (typeof this.callback == "function") {
|
|
if (this.thisObject)
|
|
this.callback.call(this.thisObject, subject, data);
|
|
else
|
|
this.callback(subject, data);
|
|
}
|
|
else // typeof this.callback == "object" (nsIObserver)
|
|
this.callback.observe(subject, topic, data);
|
|
}
|
|
}
|
|
|
|
|
|
function Subject(object) {
|
|
// Double-wrap the object and set a property identifying the wrappedJSObject
|
|
// as one of our wrappers to distinguish between subjects that are one of our
|
|
// wrappers (which we should unwrap when notifying our observers) and those
|
|
// that are real JS XPCOM components (which we should pass through unaltered).
|
|
this.wrappedJSObject = { observersModuleSubjectWrapper: true, object: object };
|
|
}
|
|
|
|
Subject.prototype = {
|
|
QueryInterface: XPCOMUtils.generateQI([]),
|
|
getHelperForLanguage: function() {},
|
|
getInterfaces: function() {}
|
|
};
|