Issue 3095 - Use a JavaScript Map in ElemHide

lib/elemHide.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
@@ skipping 12 matching lines @@
 
 let {Utils} = require("utils");
 let {IO} = require("io");
 let {Prefs} = require("prefs");
 let {ElemHideException} = require("filterClasses");
 let {FilterNotifier} = require("filterNotifier");
 let {AboutHandler} = require("elemHideHitRegistration");
 
 /**
  * Lookup table, filters by their associated key
- * @type Object
+ * @type Map
  */
-let filterByKey = Object.create(null);
+let filterByKey = new Map();
 
 /**
- * Lookup table, keys of the filters by filter text
- * @type Object
+ * Lookup table, keys of the filters by filter
+ * @type WeakMap
  */
-let keyByFilter = Object.create(null);
+let keyByFilter = new Map();
 
 /**
  * Lookup table, keys are known element hiding exceptions
  * @type Object
  */
 let knownExceptions = Object.create(null);
 
 /**
  * Lookup table, lists of element hiding exceptions by selector
  * @type Object
@@ skipping 42 matching lines @@
     let styleFile = IO.resolveFilePath(Prefs.data_directory);
     styleFile.append("elemhide.css");
     styleURL = Services.io.newFileURI(styleFile).QueryInterface(Ci.nsIFileURL);
   },
 
   /**
    * Removes all known filters
    */
   clear: function()
   {
-    filterByKey = Object.create(null);
-    keyByFilter = Object.create(null);
+    filterByKey = new Map();
+    keyByFilter = new Map();
     knownExceptions = Object.create(null);
     exceptions = Object.create(null);
     ElemHide.isDirty = false;
     ElemHide.unapply();
   },
 
   /**
    * Add a new element hiding filter
    * @param {ElemHideFilter} filter
    */
   add: function(filter)
   {
     if (filter instanceof ElemHideException)
     {
       if (filter.text in knownExceptions)
         return;
 
       let selector = filter.selector;
       if (!(selector in exceptions))
         exceptions[selector] = [];
       exceptions[selector].push(filter);
       knownExceptions[filter.text] = true;
     }
     else
     {
-      if (filter.text in keyByFilter)
+      if (keyByFilter.has(filter.text))
         return;
 
       let key;
       do {
         key = Math.random().toFixed(15).substr(5);
-      } while (key in filterByKey);
+      } while (filterByKey.has(key));
 
-      filterByKey[key] = filter;
-      keyByFilter[filter.text] = key;
+      filterByKey.set(key, filter);
+      keyByFilter.set(filter.text, key);
       ElemHide.isDirty = true;
     }
   },
 
   /**
    * Removes an element hiding filter
    * @param {ElemHideFilter} filter
    */
   remove: function(filter)
   {
     if (filter instanceof ElemHideException)
     {
       if (!(filter.text in knownExceptions))
         return;
 
       let list = exceptions[filter.selector];
       let index = list.indexOf(filter);
       if (index >= 0)
         list.splice(index, 1);
       delete knownExceptions[filter.text];
     }
     else
     {
-      if (!(filter.text in keyByFilter))
+      if (!keyByFilter.has(filter.text))
         return;
 
-      let key = keyByFilter[filter.text];
-      delete filterByKey[key];
-      delete keyByFilter[filter.text];
+      let key = keyByFilter.get(filter.text);
+      filterByKey.delete(key);
+      keyByFilter.delete(filter.text);
       ElemHide.isDirty = true;
     }
   },
 
   /**
    * Checks whether an exception rule is registered for a filter on a particular
    * domain.
    */
   getException: function(/**Filter*/ filter, /**String*/ docDomain) /**ElemHideException*/
   {
@@ skipping 100 matching lines @@
     }.bind(this));
 
     this._applying = true;
   },
 
   _generateCSSContent: function*()
   {
     // Grouping selectors by domains
     let domains = Object.create(null);
     let hasFilters = false;
-    for (let key in filterByKey)
+    for (let [key, filter] of filterByKey.entries())
     {
-      let filter = filterByKey[key];
       let domain = filter.selectorDomain || "";
 
       let list;
       if (domain in domains)
         list = domains[domain];
       else
       {
         list = Object.create(null);
         domains[domain] = list;
       }
@@ skipping 58 matching lines @@
   get styleURL()
   {
     return ElemHide.applied ? styleURL.spec : null;
   },
 
   /**
    * Retrieves an element hiding filter by the corresponding protocol key
    */
   getFilterByKey: function(/**String*/ key) /**Filter*/
   {
-    return (key in filterByKey ? filterByKey[key] : null);
+    return (filterByKey.has(key) ? filterByKey.get(key) : null);
   },
 
   /**
    * Returns a list of all selectors active on a particular domain (currently
    * used only in Chrome, Opera and Safari).
    */
   getSelectorsForDomain: function(/**String*/ domain, /**Boolean*/ specificOnly)
   {
     let result = [];
-    let keys = Object.getOwnPropertyNames(filterByKey);
-    for (let key of keys)
+    for (let filter of filterByKey.values())
     {
-      let filter = filterByKey[key];
       if (specificOnly && (!filter.domains || filter.domains[""]))
         continue;
 
       if (filter.isActiveOnDomain(domain) && !this.getException(filter, domain))
         result.push(filter.selector);
     }
     return result;
   }
 };