The Tor Browser: comparison services/common/observers.js

comparison: services/common/observers.js

services/common/observers.js

branch: TOR_BUG_9701
changeset 15: b8a032363ba2

equal deleted inserted replaced

--1:000000000000
+:3ab37bf2da4a
+/* 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() {}
+};