Issue 3208 - Don`t use numerical content types outside nsIContentPolicy.shouldLoad

lib/requestNotifier.js

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2015 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/>.
  */
 
 /**
  * @fileOverview Stores Adblock Plus data to be attached to a window.
  */
 
-Cu.import("resource://gre/modules/Services.jsm");
-
 let {Utils} = require("utils");
 let {BlockingFilter, WhitelistFilter, ElemHideBase, ElemHideFilter, ElemHideException} = require("filterClasses");
 
 let nodeData = new WeakMap();
 let windowStats = new WeakMap();
 let windowSelection = new WeakMap();
+let requestNotifierMaxId = 0;
 let requestEntryMaxId = 0;
 
-let setEntry, hasEntry, getEntry;
-// Last issue(Bug 982561) preventing us from using WeakMap fixed for FF version 32
-if (Services.vc.compare(Utils.platformVersion, "32.0a1") >= 0)
-{
-  setEntry = (map, key, value) => map.set(key, value);
-  hasEntry = (map, key) => map.has(key);
-  getEntry = (map, key) => map.get(key);
-}
-else
-{
-  // Fall back to user data
-  let dataSeed = Math.random();
-  let nodeDataProp = "abpNodeData" + dataSeed;
-  let windowStatsProp = "abpWindowStats" + dataSeed;
-  let windowSelectionProp = "abpWindowSelection" + dataSeed;
-  let getProp = function(map)
-  {
-    switch (map)
-    {
-      case nodeData:
-        return nodeDataProp;
-      case windowStats:
-        return windowStatsProp;
-      case windowSelection:
-        return windowSelectionProp;
-      default:
-        return null;
-    }
-  };
-
-  setEntry = (map, key, value) => key.setUserData(getProp(map), value, null);
-  hasEntry = (map, key) => key.getUserData(getProp(map));
-  getEntry = (map, key) => key.getUserData(getProp(map)) || undefined;
-}
-
-/**
- * List of notifiers in use - these notifiers need to receive notifications on
- * new requests.
- * @type RequestNotifier[]
- */
-let activeNotifiers = [];
+/**
+ * Active RequestNotifier instances by their ID
+ * @type Map
+ */
+let notifiers = new Map();
 
 /**
  * Creates a notifier object for a particular window. After creation the window
  * will first be scanned for previously saved requests. Once that scan is
  * complete only new requests for this window will be reported.
  * @param {Window} wnd  window to attach the notifier to
  * @param {Function} listener  listener to be called whenever a new request is found
  * @param {Object} [listenerObj]  "this" pointer to be used when calling the listener
  */
 function RequestNotifier(wnd, listener, listenerObj)
 {
   this.window = wnd;
   this.listener = listener;
   this.listenerObj = listenerObj || null;
-  activeNotifiers.push(this);
+  this.id = ++requestNotifierMaxId;
+  notifiers.set(this.id, this);
   if (wnd)
     this.startScan(wnd);
   else
     this.scanComplete = true;
 }
 exports.RequestNotifier = RequestNotifier;
 
 RequestNotifier.prototype =
 {
   /**
+   * The unique ID of this notifier.
+   * @type Integer
+   */
+  id: null,
+
+  /**
    * The window this notifier is associated with.
    * @type Window
    */
   window: null,
 
   /**
    * The listener to be called when a new request is found.
    * @type Function
    */
   listener: null,
@@ skipping 13 matching lines @@
   /**
    * Shuts down the notifier once it is no longer used. The listener
    * will no longer be called after that.
    */
   shutdown: function()
   {
     delete this.window;
     delete this.listener;
     delete this.listenerObj;
 
-    for (let i = activeNotifiers.length - 1; i >= 0; i--)
-      if (activeNotifiers[i] == this)
-        activeNotifiers.splice(i, 1);
+    notifiers.delete(this.id);
   },
 
   /**
    * Notifies listener about a new request.
    * @param {Window} wnd
    * @param {Node} node
    * @param {RequestEntry} entry
    */
   notifyListener: function(wnd, node, entry)
   {
@@ skipping 14 matching lines @@
   {
     let doc = wnd.document;
     let walker = doc.createTreeWalker(doc, Ci.nsIDOMNodeFilter.SHOW_ELEMENT, null, false);
 
     let process = function()
     {
       if (!this.listener)
         return;
 
       let node = walker.currentNode;
-      let data = getEntry(nodeData, node);
+      let data = nodeData.get(node);
       if (typeof data != "undefined")
         for (let k in data)
           this.notifyListener(wnd, node, data[k]);
 
       if (walker.nextNode())
         Utils.runAsync(process);
       else
       {
         // Done with the current window, start the scan for its frames
         for (let i = 0; i < wnd.frames.length; i++)
           this.startScan(wnd.frames[i]);
 
         this.eventsPosted--;
         if (!this.eventsPosted)
         {
           this.scanComplete = true;
           this.notifyListener(wnd, null, null);
         }
       }
     }.bind(this);
 
     // Process each node in a separate event to allow other events to process
     this.eventsPosted++;
     Utils.runAsync(process);
   }
 };
 
 RequestNotifier.storeSelection = function(/**Window*/ wnd, /**String*/ selection)
 {
-  setEntry(windowSelection, wnd.document, selection);
+  windowSelection.set(wnd.document, selection);
 };
 RequestNotifier.getSelection = function(/**Window*/ wnd) /**String*/
 {
-  if (hasEntry(windowSelection, wnd.document))
-    return getEntry(windowSelection, wnd.document);
+  if (windowSelection.has(wnd.document))
+    return windowSelection.get(wnd.document);
   else
     return null;
 };
 
 /**
  * Attaches request data to a DOM node.
  * @param {Node} node   node to attach data to
  * @param {Window} topWnd   top-level window the node belongs to
  * @param {String} contentType   request type, e.g. "IMAGE"
  * @param {String} docDomain  domain of the document that initiated the request
  * @param {Boolean} thirdParty  will be true if a third-party server has been requested
  * @param {String} location   the address that has been requested
  * @param {Filter} filter   filter applied to the request or null if none
  */
 RequestNotifier.addNodeData = function(/**Node*/ node, /**Window*/ topWnd, /**String*/ contentType, /**String*/ docDomain, /**Boolean*/ thirdParty, /**String*/ location, /**Filter*/ filter)

[Thomas Greiner, 2015/11/02 18:54:37]

Detail: The inline documentation here is highly redundant.

[Wladimir Palant, 2015/11/03 11:26:49]

True, this aspect of my original patch got lost. Will improve JSDoc comments in
a separate commit.

 {
   return new RequestEntry(node, topWnd, contentType, docDomain, thirdParty, location, filter);
 }
 
 /**
  * Retrieves the statistics for a window.
  * @result {Object} Object with the properties items, blocked, whitelisted, hidden, filters containing statistics for the window (might be null)
  */
 RequestNotifier.getWindowStatistics = function(/**Window*/ wnd)
 {
-  if (hasEntry(windowStats, wnd.document))
-    return getEntry(windowStats, wnd.document);
+  if (windowStats.has(wnd.document))
+    return windowStats.get(wnd.document);
   else
     return null;
 }
 
 /**
  * Retrieves the request entry associated with a DOM node.
  * @param {Node} node
  * @param {Boolean} noParent  if missing or false, the search will extend to the parent nodes until one is found that has data associated with it
  * @param {Integer} [type] request type to be looking for
  * @param {String} [location] request location to be looking for
  * @result {[Node, RequestEntry]}
  * @static
  */
 RequestNotifier.getDataForNode = function(node, noParent, type, location)
 {
   while (node)
   {
-    let data = getEntry(nodeData, node);
+    let data = nodeData.get(node);
     if (typeof data != "undefined")
     {
       let entry = null;
       // Look for matching entry
       for (let k in data)
       {
         if ((!entry || entry.id < data[k].id) &&
             (typeof type == "undefined" || data[k].type == type) &&
             (typeof location == "undefined" || data[k].location == location))
         {
@@ skipping 24 matching lines @@
   this.type = contentType;
   this.docDomain = docDomain;
   this.thirdParty = thirdParty;
   this.location = location;
   this.filter = filter;
   this.id = ++requestEntryMaxId;
 
   this.attachToNode(node);
 
   // Update window statistics
-  if (!hasEntry(windowStats, topWnd.document))
-  {
-    setEntry(windowStats, topWnd.document, {
+  if (!windowStats.has(topWnd.document))
+  {
+    windowStats.set(topWnd.document, {
       items: 0,
       hidden: 0,
       blocked: 0,
       whitelisted: 0,
       filters: {}
     });
   }
 
-  let stats = getEntry(windowStats, topWnd.document);
+  let stats = windowStats.get(topWnd.document);
   if (!filter || !(filter instanceof ElemHideBase))
     stats.items++;
   if (filter)
   {
     if (filter instanceof BlockingFilter)
       stats.blocked++;
     else if (filter instanceof WhitelistFilter || filter instanceof ElemHideException)
       stats.whitelisted++;
     else if (filter instanceof ElemHideFilter)
       stats.hidden++;
 
     if (filter.text in stats.filters)
       stats.filters[filter.text]++;
     else
       stats.filters[filter.text] = 1;
   }
 
   // Notify listeners
-  for (let notifier of activeNotifiers)
+  for (let notifier of notifiers.values())
     if (!notifier.window || notifier.window == topWnd)
       notifier.notifyListener(topWnd, node, this);
 }
 RequestEntry.prototype =
 {
   /**
    * id of request (used to determine last entry attached to a node)
    * @type integer
    */
   id: 0,
@@ skipping 37 matching lines @@
   get localizedDescr()
   {
     return require("contentPolicy").Policy.localizedDescr.get(this.type);
   },
 
   /**
    * Attaches this request object to a DOM node.
    */
   attachToNode: function(/**Node*/ node)
   {
-    let existingData = getEntry(nodeData, node);
+    let existingData = nodeData.get(node);
     if (typeof existingData == "undefined")
     {
       existingData = {};
-      setEntry(nodeData, node, existingData);
+      nodeData.set(node, existingData);
     }
 
     // Add this request to the node data
     existingData[this.type + " " + this.location] = this;
   }
 };