Issue 6402 - Split filter hit / request logging out into own API

lib/hitLogger.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
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 /** @module hitLogger */
 
 "use strict";
 
-const {desc} = require("coreUtils");
-const {extractHostFromFrame} = require("url");
-const {EventEmitter} = require("events");
-const {FilterStorage} = require("filterStorage");
-const {port} = require("messaging");
-const {RegExpFilter, ElemHideFilter} = require("filterClasses");
+const {extractHostFromFrame} = require("./url");
+const {EventEmitter} = require("../adblockpluscore/lib/events");
+const {FilterStorage} = require("../adblockpluscore/lib/filterStorage");
+const {port} = require("./messaging");
+const {RegExpFilter,
+       ElemHideFilter} = require("../adblockpluscore/lib/filterClasses");
 
-const nonRequestTypes = ["DOCUMENT", "ELEMHIDE", "GENERICBLOCK", "GENERICHIDE"];
+const nonRequestTypes = exports.nonRequestTypes = [
+  "DOCUMENT", "ELEMHIDE", "GENERICBLOCK", "GENERICHIDE", "CSP"
+];
 
-let HitLogger = exports.HitLogger = Object.create(new EventEmitter(), desc({
-  off(tabId, listener)
-  {
-    this.__proto__.off(tabId, listener);

[kzar, 2018/03/21 15:18:46]

I wanted to use `super` here instead of `this.__proto__` but that didn't work.
I'm not sure why.

-
-    // EventEmitter leaves an empty array once the last listener for an event
-    // is removed. Usually that's fine, but in this case we need _listeners.size
-    // and _listeners.has to be accurate.
-    let listeners = this._listeners.get(tabId);
-    if (listeners && listeners.length == 0)
-      this._listeners.delete(tabId);
-  }
-}));
+let eventEmitter = new EventEmitter();
 
 /**
- * Logs a request for a page if there's something (e.g. devtools panel)
- * listening.
- *
- * @param {number}   tabId         The page the request occured on or -1 if
- *                                 the request isn't associated with a page
- * @param {string}   url           The URL of the request
- * @param {string}   type          The request type
- * @param {string}   docDomain     The IDN-decoded hostname of the document
- * @param {boolean}  thirdParty    Whether the origin of the request and
- *                                 document differs
- * @param {?string}  sitekey       The active sitekey if there is any
- * @param {?boolean} specificOnly  Whether generic filters should be ignored
- * @param {?BlockingFilter} filter The matched filter or null if there is no
- *                                 match
+ * @namespace
+ * @static
  */
-exports.logRequest = function(tabId, url, type, docDomain, thirdParty, sitekey,
-                              specificOnly, filter)
-{
-  if (HitLogger._listeners.size == 0)
-    return;
+let HitLogger = exports.HitLogger = {
+  /**
+   * Adds a listener for requests, filter hits etc related to the tab.
+   *
+   * Note: Calling code is responsible for removing the listener again,
+   *       it will not be automatically removed when the tab is closed.
+   *
+   * @param {number} tabId
+   * @param {function} listener
+   */
+  addListener: eventEmitter.on.bind(eventEmitter),
 
-  let request = {url, type, docDomain, thirdParty, sitekey, specificOnly,
-                 tabId};
-  for (let loggerTabId of HitLogger._listeners.keys())
-    if (tabId == -1 || tabId == loggerTabId)
-      HitLogger.emit(tabId, request, filter);
+  /**
+   * Removes a listener for the tab.
+   *
+   * @param {number} tabId
+   * @param {function} listener
+   */
+  removeListener: eventEmitter.off.bind(eventEmitter),
+
+  /**
+   * Checks whether a tab is being inspected by anything.
+   *
+   * @param {number} tabId
+   * @return {boolean}
+   */
+  hasListener(tabId)
+  {
+    let listeners = eventEmitter._listeners.get(tabId);
+    return listeners && listeners.length > 0;
+  }
 };
 
 /**
- * Logs active element hiding filters for a page if there's something's
- * (e.g. devtools panel) listening.
+ * Logs a request associated with a tab or multiple tabs.
  *
- * @param {int}      tabId      The page the elements were hidden on
+ * @param {number[]} tabIds
+ *   The tabIds associated with the request
+ * @param {Object} request
+ *   The request to log
+ * @param {string} request.url
+ *   The URL of the request
+ * @param {string} request.type
+ *  The request type
+ * @param {string} request.docDomain
+ *  The hostname of the document
+ * @param {boolean} request.thirdParty
+ *   Whether the origin of the request and document differs
+ * @param {?string} request.sitekey
+ *   The active sitekey if there is any
+ * @param {?boolean} request.specificOnly
+ *   Whether generic filters should be ignored
+ * @param {?BlockingFilter} filter
+ *  The matched filter or null if there is no match
+ */
+exports.logRequest = (tabIds, request, filter) =>
+{
+  for (let tabId of tabIds)
+    eventEmitter.emit(tabId, request, filter);
+};
+
+/**
+ * Logs active element hiding filters for a tab.
+ *
+ * @param {number}   tabId      The ID of the tab, the elements were hidden in
  * @param {string[]} selectors  The selectors of applied ElemHideFilters
  * @param {string[]} filters    The text of applied ElemHideEmulationFilters
- * @param {string}   docDomain  The IDN-decoded hostname of the document
+ * @param {string}   docDomain  The hostname of the document
  */
-exports.logHiddenElements = function(tabId, selectors, filters, docDomain)
+function logHiddenElements(tabId, selectors, filters, docDomain)
 {
-  if (HitLogger._listeners.has(tabId))
+  if (HitLogger.hasListener(tabId))
   {
     for (let subscription of FilterStorage.subscriptions)
     {
       if (subscription.disabled)
         continue;
 
       for (let filter of subscription.filters)
       {
         // We only know the exact filter in case of element hiding emulation.
         // For regular element hiding filters, the content script only knows
         // the selector, so we have to find a filter that has an identical
         // selector and is active on the domain the match was reported from.
         let isActiveElemHideFilter = filter instanceof ElemHideFilter &&
                                      selectors.includes(filter.selector) &&
                                      filter.isActiveOnDomain(docDomain);
 
         if (isActiveElemHideFilter || filters.includes(filter.text))
-          HitLogger.emit(tabId, {type: "ELEMHIDE", docDomain, tabId}, filter);
+          eventEmitter.emit(tabId, {type: "ELEMHIDE", docDomain}, filter);
       }
+    }
+  }
+}
+
+/**
+ * Logs a whitelisting filter that disables (some kind of)
+ * blocking for a particular document.
+ *
+ * @param {number}       tabId     The tabId the whitelisting is active for
+ * @param {string}       url       The url of the whitelisted document
+ * @param {number}       typeMask  The bit mask of whitelisting types checked
+ *                                 for
+ * @param {string}       docDomain The hostname of the parent document
+ * @param {WhitelistFilter} filter The matched whitelisting filter
+ */
+exports.logWhitelistedDocument = (tabId, url, typeMask, docDomain, filter) =>
+{
+  if (HitLogger.hasListener(tabId))
+  {
+    for (let type of nonRequestTypes)
+    {
+      if (typeMask & filter.contentType & RegExpFilter.typeMap[type])
+        eventEmitter.emit(tabId, {url, type, docDomain}, filter);
     }
   }
 };
 
-/**
- * Logs a whitelisting filter, that disables (some kind of) blocking
- * for a particular document if a devtools panel or similiar is listening.
- *
- * @param {number}       tabId     The page the whitelisting is active on
- * @param {string}       url       The url of the whitelisted document
- * @param {number}       typeMask  The bit mask of whitelisting types checked
- *                                 for
- * @param {string}       docDomain The IDN-decoded hostname of the parent
- *                                 document
- * @param {WhitelistFilter} filter The matched whitelisting filter
- */
-exports.logWhitelistedDocument = function(tabId, url, typeMask, docDomain,
-                                          filter)
-{
-  if (HitLogger._listeners.has(tabId))
-  {
-    for (let type of nonRequestTypes)
-    {
-      if (typeMask & filter.contentType & RegExpFilter.typeMap[type])
-        HitLogger.emit(tabId, {type, url, docDomain, tabId}, filter);
-    }
-  }
-};
-
-/**
- * Checks whether anything (e.g. devtools panel) is listening for a page's hits.
- */
-exports.hasListener = function(tabId)
-{
-  return HitLogger._listeners.has(tabId);
-};
-
 port.on("hitLogger.traceElemHide", (message, sender) =>
 {
-  exports.logHiddenElements(
+  logHiddenElements(
     sender.page.id, message.selectors, message.filters,
     extractHostFromFrame(sender.frame)
   );
 });