The Tor Browser: comparison toolkit/devtools/event-emitter.js

comparison: toolkit/devtools/event-emitter.js

toolkit/devtools/event-emitter.js

branch: TOR_BUG_9701
changeset 15: b8a032363ba2

equal deleted inserted replaced

--1:000000000000
+:ac77cfb6e8d4
+/* 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/. */
+/**
+* EventEmitter.
+*/
+this.EventEmitter = function EventEmitter() {};
+if (typeof(require) === "function") {
+module.exports = EventEmitter;
+var {Cu, components} = require("chrome");
+} else {
+var EXPORTED_SYMBOLS = ["EventEmitter"];
+var Cu = this["Components"].utils;
+var components = Components;
+}
+const { Promise: promise } = Cu.import("resource://gre/modules/Promise.jsm", {});
+const { Services } = Cu.import("resource://gre/modules/Services.jsm");
+/**
+* Decorate an object with event emitter functionality.
+*
+* @param Object aObjectToDecorate
+*        Bind all public methods of EventEmitter to
+*        the aObjectToDecorate object.
+*/
+EventEmitter.decorate = function EventEmitter_decorate (aObjectToDecorate) {
+let emitter = new EventEmitter();
+aObjectToDecorate.on = emitter.on.bind(emitter);
+aObjectToDecorate.off = emitter.off.bind(emitter);
+aObjectToDecorate.once = emitter.once.bind(emitter);
+aObjectToDecorate.emit = emitter.emit.bind(emitter);
+};
+EventEmitter.prototype = {
+/**
+* Connect a listener.
+*
+* @param string aEvent
+*        The event name to which we're connecting.
+* @param function aListener
+*        Called when the event is fired.
+*/
+on: function EventEmitter_on(aEvent, aListener) {
+if (!this._eventEmitterListeners)
+this._eventEmitterListeners = new Map();
+if (!this._eventEmitterListeners.has(aEvent)) {
+this._eventEmitterListeners.set(aEvent, []);
+}
+this._eventEmitterListeners.get(aEvent).push(aListener);
+},
+/**
+* Listen for the next time an event is fired.
+*
+* @param string aEvent
+*        The event name to which we're connecting.
+* @param function aListener
+*        (Optional) Called when the event is fired. Will be called at most
+*        one time.
+* @return promise
+*        A promise which is resolved when the event next happens. The
+*        resolution value of the promise is the first event argument. If
+*        you need access to second or subsequent event arguments (it's rare
+*        that this is needed) then use aListener
+*/
+once: function EventEmitter_once(aEvent, aListener) {
+let deferred = promise.defer();
+let handler = function(aEvent, aFirstArg) {
+this.off(aEvent, handler);
+if (aListener) {
+aListener.apply(null, arguments);
+}
+deferred.resolve(aFirstArg);
+}.bind(this);
+handler._originalListener = aListener;
+this.on(aEvent, handler);
+return deferred.promise;
+},
+/**
+* Remove a previously-registered event listener.  Works for events
+* registered with either on or once.
+*
+* @param string aEvent
+*        The event name whose listener we're disconnecting.
+* @param function aListener
+*        The listener to remove.
+*/
+off: function EventEmitter_off(aEvent, aListener) {
+if (!this._eventEmitterListeners)
+return;
+let listeners = this._eventEmitterListeners.get(aEvent);
+if (listeners) {
+this._eventEmitterListeners.set(aEvent, listeners.filter(l => {
+return l !== aListener && l._originalListener !== aListener;
+}));
+}
+},
+/**
+* Emit an event.  All arguments to this method will
+* be sent to listner functions.
+*/
+emit: function EventEmitter_emit(aEvent) {
+this.logEvent(aEvent, arguments);
+if (!this._eventEmitterListeners || !this._eventEmitterListeners.has(aEvent)) {
+return;
+}
+let originalListeners = this._eventEmitterListeners.get(aEvent);
+for (let listener of this._eventEmitterListeners.get(aEvent)) {
+// If the object was destroyed during event emission, stop
+// emitting.
+if (!this._eventEmitterListeners) {
+break;
+}
+// If listeners were removed during emission, make sure the
+// event handler we're going to fire wasn't removed.
+if (originalListeners === this._eventEmitterListeners.get(aEvent) ||
+this._eventEmitterListeners.get(aEvent).some(function(l) l === listener)) {
+try {
+listener.apply(null, arguments);
+}
+catch (ex) {
+// Prevent a bad listener from interfering with the others.
+let msg = ex + ": " + ex.stack;
+Cu.reportError(msg);
+dump(msg + "\n");
+}
+}
+}
+},
+logEvent: function(aEvent, args) {
+let logging = Services.prefs.getBoolPref("devtools.dump.emit");
+if (logging) {
+let caller = components.stack.caller.caller;
+let func = caller.name;
+let path = caller.filename.split(/ -> /)[1] + ":" + caller.lineNumber;
+let argOut = "(";
+if (args.length === 1) {
+argOut += aEvent;
+}
+let out = "EMITTING: ";
+// We need this try / catch to prevent any dead object errors.
+try {
+for (let i = 1; i < args.length; i++) {
+if (i === 1) {
+argOut = "(" + aEvent + ", ";
+} else {
+argOut += ", ";
+}
+let arg = args[i];
+argOut += arg;
+if (arg && arg.nodeName) {
+argOut += " (" + arg.nodeName;
+if (arg.id) {
+argOut += "#" + arg.id;
+}
+if (arg.className) {
+argOut += "." + arg.className;
+}
+argOut += ")";
+}
+}
+} catch(e) {
+// Object is dead so the toolbox is most likely shutting down,
+// do nothing.
+}
+argOut += ")";
+out += "emit" + argOut + " from " + func + "() -> " + path + "\n";
+dump(out);
+}
+},
+};