Issue 7202 - Add hasListeners method to EventEmitter

lib/events.js

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-present eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 17 matching lines @@
   }
 
   /**
    * Adds a listener for the specified event name.
    *
    * @param {string}   name
    * @param {function} listener
    */
   on(name, listener)
   {
-    let listeners = this._listeners.get(name);
+    let listeners = this._listeners.size > 0 ? this._listeners.get(name) : null;

[hub, 2019/01/09 22:42:40]

I don't see how this is faster (since it is part of the "optimize all methods"
change) ? And given that we only check whether listener is falsey, it shouldn't
matter whether it is undefined or null.

[Manish Jethani, 2019/01/09 23:09:45]

This is not about null vs. undefined, this is about avoiding the lookup via
get() when there are no listeners for any event (as is the case with
lib/hitLogger.js in the extension most of the time because DevTools is not open
for any tab).

If you mean specifically about this instance in the on() function, then again
avoiding lookup for the first listener for an event might help.

I don't feel very strongly about on() and off() but I think it helps in the case
of emit() because an event is emitted for each filter hit.

[Manish Jethani, 2019/01/09 23:11:55]

Having said this, the "optimize all methods" part is not necessary for this
change, I can drop it if you think we should do it separately.

[Manish Jethani, 2019/01/10 03:50:13]

Alright, so I wrote this test:

  // test.js
  let {EventEmitter} = require("./lib/events");
  
  let eventEmitter = new EventEmitter();
    
  let start = Date.now();    
  for (let i = 0; i < 10000000; i++)
    eventEmitter.emit("foo");    
  console.log(Date.now() - start);

For me it's thrice as fast with the additional check for size.

I think we could skip the checks in on() and off() but keep them in listeners(),
hasListeners() and emit(). There is a cost (~10%) when the size is in fact
non-zero.

What do you think?

     if (listeners)
       listeners.push(listener);
     else
       this._listeners.set(name, [listener]);
   }
 
   /**
    * Removes a listener for the specified event name.
    *
    * @param {string}   name
    * @param {function} listener
    */
   off(name, listener)
   {
-    let listeners = this._listeners.get(name);
+    let listeners = this._listeners.size > 0 ? this._listeners.get(name) : null;
     if (listeners)
     {
-      let idx = listeners.indexOf(listener);
-      if (idx != -1)
-        listeners.splice(idx, 1);
+      if (listeners.length > 1)
+      {
+        let idx = listeners.indexOf(listener);
+        if (idx != -1)
+          listeners.splice(idx, 1);
+      }
+      else if (listeners[0] === listener)
+      {
+        // We must use strict equality above for compatibility with
+        // Array.prototype.indexOf
+        this._listeners.delete(name);
+      }
     }
   }
 
   /**
    * Adds a one time listener and returns a promise that
    * is resolved the next time the specified event is emitted.
    *
    * @param {string} name
    * @returns {Promise}
    */
@@ skipping 12 matching lines @@
   }
 
   /**
    * Returns a copy of the array of listeners for the specified event.
    *
    * @param {string} name
    * @returns {Array.<function>}
    */
   listeners(name)
   {
-    let listeners = this._listeners.get(name);
+    let listeners = this._listeners.size > 0 ? this._listeners.get(name) : null;
     return listeners ? listeners.slice() : [];
   }
 
   /**
+   * Checks whether there are any listeners for the specified event.
+   *
+   * @param {string} [name] The name of the event. If omitted, checks whether
+   *   there are any listeners for any event.
+   * @returns {boolean}
+   */
+  hasListeners(name)
+  {
+    return this._listeners.size > 0 &&
+           (typeof name == "undefined" || this._listeners.has(name));
+  }
+
+  /**
    * Calls all previously added listeners for the given event name.
    *
    * @param {string} name
    * @param {...*}   [args]
    */
   emit(name, ...args)
   {
-    let listeners = this.listeners(name);
-    for (let listener of listeners)
-      listener(...args);
+    let listeners = this._listeners.size > 0 ? this._listeners.get(name) : null;
+    if (listeners)
+    {
+      for (let listener of listeners.slice())
+        listener(...args);
+    }
   }
 }
 
 exports.EventEmitter = EventEmitter;