Issue 4353 - Remove deprecated __proto__ syntax

lib/filterClasses.js

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2016 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 Definition of Filter class and its subclasses.
  */
 
 let {FilterNotifier} = require("filterNotifier");
+let {desc} = require("coreUtils");
 
 /**
  * Abstract base class for filters
  *
  * @param {String} text   string representation of the filter
  * @constructor
  */
 function Filter(text)
 {
   this.text = text;
@@ skipping 170 matching lines @@
  * @augments Filter
  */
 function InvalidFilter(text, reason)
 {
   Filter.call(this, text);
 
   this.reason = reason;
 }
 exports.InvalidFilter = InvalidFilter;
 
-InvalidFilter.prototype =
-{
-  __proto__: Filter.prototype,
-
+InvalidFilter.prototype = Object.create(Filter.prototype, desc({
   type: "invalid",
 
   /**
    * Reason why this filter is invalid
    * @type String
    */
   reason: null,
 
   /**
    * See Filter.serialize()
    */
   serialize: function(buffer) {}
-};
+}));
 
 /**
  * Class for comments
  * @param {String} text see Filter()
  * @constructor
  * @augments Filter
  */
 function CommentFilter(text)
 {
   Filter.call(this, text);
 }
 exports.CommentFilter = CommentFilter;
 
-CommentFilter.prototype =
-{
-  __proto__: Filter.prototype,
-
+CommentFilter.prototype = Object.create(Filter.prototype, desc({
   type: "comment",
 
   /**
    * See Filter.serialize()
    */
   serialize: function(buffer) {}
-};
+}));
 
 /**
  * Abstract base class for filters that can get hits
  * @param {String} text see Filter()
  * @param {String} [domains] Domains that the filter is restricted to separated by domainSeparator e.g. "foo.com|bar.com|~baz.com"
  * @constructor
  * @augments Filter
  */
 function ActiveFilter(text, domains)
 {
   Filter.call(this, text);
 
   this.domainSource = domains;
 }
 exports.ActiveFilter = ActiveFilter;
 
-ActiveFilter.prototype =
-{
-  __proto__: Filter.prototype,
-
+ActiveFilter.prototype = Object.create(Filter.prototype, desc({
   _disabled: false,
   _hitCount: 0,
   _lastHit: 0,
 
   /**
    * Defines whether the filter is disabled
    * @type Boolean
    */
-  get disabled()
-  {
-    return this._disabled;
-  },
-  set disabled(value)
-  {
-    if (value != this._disabled)
+  disabled: {
+    get: function()
     {
-      let oldValue = this._disabled;
-      this._disabled = value;
-      FilterNotifier.triggerListeners("filter.disabled", this, value, oldValue);
+      return this._disabled;
+    },
+    set: function(value)
+    {
+      if (value != this._disabled)
+      {
+        let oldValue = this._disabled;
+        this._disabled = value;
+        FilterNotifier.triggerListeners("filter.disabled", this,
+        value, oldValue);
+      }
+      return this._disabled;
     }
-    return this._disabled;
   },
 
   /**
    * Number of hits on the filter since the last reset
    * @type Number
    */
-  get hitCount()
-  {
-    return this._hitCount;
-  },
-  set hitCount(value)
-  {
-    if (value != this._hitCount)
+  hitCount: {
+    get: function()
     {
-      let oldValue = this._hitCount;
-      this._hitCount = value;
-      FilterNotifier.triggerListeners("filter.hitCount", this, value, oldValue);
+      return this._hitCount;
+    },
+    set: function(value)
+    {
+      if (value != this._hitCount)
+      {
+        let oldValue = this._hitCount;
+        this._hitCount = value;
+        FilterNotifier.triggerListeners("filter.hitCount", this,
+        value, oldValue);
+      }
+      return this._hitCount;
     }
-    return this._hitCount;
   },
 
   /**
    * Last time the filter had a hit (in milliseconds since the beginning of the epoch)
    * @type Number
    */
-  get lastHit()
-  {
-    return this._lastHit;
-  },
-  set lastHit(value)
-  {
-    if (value != this._lastHit)
+  lastHit: {
+    get: function()
     {
-      let oldValue = this._lastHit;
-      this._lastHit = value;
-      FilterNotifier.triggerListeners("filter.lastHit", this, value, oldValue);
+      return this._lastHit;
+    },
+    set: function(value)
+    {
+      if (value != this._lastHit)
+      {
+        let oldValue = this._lastHit;
+        this._lastHit = value;
+        FilterNotifier.triggerListeners("filter.lastHit", this,
+        value, oldValue);
+      }
+      return this._lastHit;
     }
-    return this._lastHit;
   },
 
   /**
    * String that the domains property should be generated from
    * @type String
    */
   domainSource: null,
 
   /**
    * Separator character used in domainSource property, must be overridden by subclasses
@@ skipping 12 matching lines @@
    * Determines whether domainSource is already upper-case,
    * can be overridden by subclasses.
    * @type Boolean
    */
   domainSourceIsUpperCase: false,
 
   /**
    * Map containing domains that this filter should match on/not match on or null if the filter should match on all domains
    * @type Object
    */
-  get domains()
-  {
-    // Despite this property being cached, the getter is called
-    // several times on Safari, due to WebKit bug 132872
-    let prop = Object.getOwnPropertyDescriptor(this, "domains");
-    if (prop)
-      return prop.value;
+  domains: {
+    get: function()
+    {
+      // Despite this property being cached, the getter is called
+      // several times on Safari, due to WebKit bug 132872
+      let prop = Object.getOwnPropertyDescriptor(this, "domains");
+      if (prop)
+        return prop.value;
 
-    let domains = null;
+      let domains = null;
 
-    if (this.domainSource)
-    {
-      let source = this.domainSource;
-      if (!this.domainSourceIsUpperCase) {
-        // RegExpFilter already have uppercase domains
-        source = source.toUpperCase();
-      }
-      let list = source.split(this.domainSeparator);
-      if (list.length == 1 && list[0][0] != "~")
+      if (this.domainSource)
       {
-        // Fast track for the common one-domain scenario
-        domains = Object.create(null);
-        domains[""] = false;
-        if (this.ignoreTrailingDot)
-          list[0] = list[0].replace(/\.+$/, "");
-        domains[list[0]] = true;
-      }
-      else
-      {
-        let hasIncludes = false;
-        for (let i = 0; i < list.length; i++)
+        let source = this.domainSource;
+        if (!this.domainSourceIsUpperCase) {
+          // RegExpFilter already have uppercase domains
+          source = source.toUpperCase();
+        }
+        let list = source.split(this.domainSeparator);
+        if (list.length == 1 && list[0][0] != "~")
         {
-          let domain = list[i];
+          // Fast track for the common one-domain scenario
+          domains = Object.create(null);
+          domains[""] = false;
           if (this.ignoreTrailingDot)
-            domain = domain.replace(/\.+$/, "");
-          if (domain == "")
-            continue;
+            list[0] = list[0].replace(/\.+$/, "");
+          domains[list[0]] = true;
+        }
+        else
+        {
+          let hasIncludes = false;
+          for (let i = 0; i < list.length; i++)
+          {
+            let domain = list[i];
+            if (this.ignoreTrailingDot)
+              domain = domain.replace(/\.+$/, "");
+            if (domain == "")
+              continue;
 
-          let include;
-          if (domain[0] == "~")
-          {
-            include = false;
-            domain = domain.substr(1);
+            let include;
+            if (domain[0] == "~")
+            {
+              include = false;
+              domain = domain.substr(1);
+            }
+            else
+            {
+              include = true;
+              hasIncludes = true;
+            }
+
+            if (!domains)
+              domains = Object.create(null);
+
+            domains[domain] = include;
           }
-          else
-          {
-            include = true;
-            hasIncludes = true;
-          }
+          domains[""] = !hasIncludes;
+        }
 
-          if (!domains)
-            domains = Object.create(null);
-
-          domains[domain] = include;
-        }
-        domains[""] = !hasIncludes;
+        this.domainSource = null;
       }
 
-      this.domainSource = null;
+      Object.defineProperty(this, "domains", {value: domains, enumerable: true});
+      return this.domains;
     }
-
-    Object.defineProperty(this, "domains", {value: domains, enumerable: true});
-    return this.domains;
   },
 
   /**
    * Array containing public keys of websites that this filter should apply to
    * @type string[]
    */
   sitekeys: null,
 
   /**
    * Checks whether this filter is active on a domain.
@@ skipping 70 matching lines @@
     {
       Filter.prototype.serialize.call(this, buffer);
       if (this._disabled)
         buffer.push("disabled=true");
       if (this._hitCount)
         buffer.push("hitCount=" + this._hitCount);
       if (this._lastHit)
         buffer.push("lastHit=" + this._lastHit);
     }
   }
-};
+}));
 
 /**
  * Abstract base class for RegExp-based filters
  * @param {String} text see Filter()
  * @param {String} regexpSource filter part that the regular expression should be build from
  * @param {Number} [contentType] Content types the filter applies to, combination of values from RegExpFilter.typeMap
  * @param {Boolean} [matchCase] Defines whether the filter should distinguish between lower and upper case letters
  * @param {String} [domains] Domains that the filter is restricted to, e.g. "foo.com|bar.com|~baz.com"
  * @param {Boolean} [thirdParty] Defines whether the filter should apply to third-party or first-party content only
  * @param {String} [sitekeys] Public keys of websites that this filter should apply to
@@ skipping 20 matching lines @@
     Object.defineProperty(this, "regexp", {value: regexp});
   }
   else
   {
     // No need to convert this filter to regular expression yet, do it on demand
     this.regexpSource = regexpSource;
   }
 }
 exports.RegExpFilter = RegExpFilter;
 
-RegExpFilter.prototype =
-{
-  __proto__: ActiveFilter.prototype,
-
+RegExpFilter.prototype = Object.create(ActiveFilter.prototype, desc({
   /**
    * @see ActiveFilter.domainSourceIsUpperCase
    */
   domainSourceIsUpperCase: true,
 
   /**
    * Number of filters contained, will always be 1 (required to optimize Matcher).
    * @type Integer
    */
   length: 1,
 
   /**
    * @see ActiveFilter.domainSeparator
    */
   domainSeparator: "|",
 
   /**
    * Expression from which a regular expression should be generated - for delayed creation of the regexp property
    * @type String
    */
   regexpSource: null,
   /**
    * Regular expression to be used when testing against this filter
    * @type RegExp
    */
-  get regexp()
-  {
-    // Despite this property being cached, the getter is called
-    // several times on Safari, due to WebKit bug 132872
-    let prop = Object.getOwnPropertyDescriptor(this, "regexp");
-    if (prop)
-      return prop.value;
+  regexp: {
+    get: function()
+    {
+      // Despite this property being cached, the getter is called
+      // several times on Safari, due to WebKit bug 132872
+      let prop = Object.getOwnPropertyDescriptor(this, "regexp");
+      if (prop)
+        return prop.value;
 
-    let source = Filter.toRegExp(this.regexpSource);
-    let regexp = new RegExp(source, this.matchCase ? "" : "i");
-    Object.defineProperty(this, "regexp", {value: regexp});
-    return regexp;
+      let source = Filter.toRegExp(this.regexpSource);
+      let regexp = new RegExp(source, this.matchCase ? "" : "i");
+      Object.defineProperty(this, "regexp", {value: regexp});
+      return regexp;
+    }
   },
+
   /**
    * Content types the filter applies to, combination of values from RegExpFilter.typeMap
    * @type Number
    */
   contentType: 0x7FFFFFFF,
   /**
    * Defines whether the filter should distinguish between lower and upper case letters
    * @type Boolean
    */
   matchCase: false,
   /**
    * Defines whether the filter should apply to third-party or first-party content only. Can be null (apply to all content).
    * @type Boolean
    */
   thirdParty: null,
 
   /**
    * String that the sitekey property should be generated from
    * @type String
    */
   sitekeySource: null,
 
   /**
    * Array containing public keys of websites that this filter should apply to
    * @type string[]
    */
-  get sitekeys()
-  {
-    // Despite this property being cached, the getter is called
-    // several times on Safari, due to WebKit bug 132872
-    let prop = Object.getOwnPropertyDescriptor(this, "sitekeys");
-    if (prop)
-      return prop.value;
+  sitekeys: {
+    get: function()
+    {
+      // Despite this property being cached, the getter is called
+      // several times on Safari, due to WebKit bug 132872
+      let prop = Object.getOwnPropertyDescriptor(this, "sitekeys");
+      if (prop)
+        return prop.value;
 
-    let sitekeys = null;
+      let sitekeys = null;
 
-    if (this.sitekeySource)
-    {
-      sitekeys = this.sitekeySource.split("|");
-      this.sitekeySource = null;
+      if (this.sitekeySource)
+      {
+        sitekeys = this.sitekeySource.split("|");
+        this.sitekeySource = null;
+      }
+
+      Object.defineProperty(this, "sitekeys", {value: sitekeys, enumerable: true});
+      return this.sitekeys;
     }
-
-    Object.defineProperty(this, "sitekeys", {value: sitekeys, enumerable: true});
-    return this.sitekeys;
   },
 
   /**
    * Tests whether the URL matches this filter
    * @param {String} location URL to be tested
    * @param {number} typeMask bitmask of content / request types to match
    * @param {String} docDomain domain name of the document that loads the URL
    * @param {Boolean} thirdParty should be true if the URL is a third-party request
    * @param {String} sitekey public key provided by the document
    * @return {Boolean} true in case of a match
    */
   matches: function(location, typeMask, docDomain, thirdParty, sitekey)
   {
     if (this.contentType & typeMask &&
         (this.thirdParty == null || this.thirdParty == thirdParty) &&
         this.isActiveOnDomain(docDomain, sitekey) && this.regexp.test(location))
     {
       return true;
     }
 
     return false;
+  },
+
+  // Required to optimize Matcher, see also RegExpFilter.prototype.length
+  0: {
+    get: function() { return this; }
   }
-};
-
-// Required to optimize Matcher, see also RegExpFilter.prototype.length
-Object.defineProperty(RegExpFilter.prototype, "0",
-{
-  get: function() { return this; }
-});
+}));
 
 /**
  * Creates a RegExp filter from its text representation
  * @param {String} text   same as in Filter()
  */
 RegExpFilter.fromText = function(text)
 {
   let blocking = true;
   let origText = text;
   if (text.indexOf("@@") == 0)
@@ skipping 119 matching lines @@
  * @augments RegExpFilter
  */
 function BlockingFilter(text, regexpSource, contentType, matchCase, domains, thirdParty, sitekeys, collapse)
 {
   RegExpFilter.call(this, text, regexpSource, contentType, matchCase, domains, thirdParty, sitekeys);
 
   this.collapse = collapse;
 }
 exports.BlockingFilter = BlockingFilter;
 
-BlockingFilter.prototype =
-{
-  __proto__: RegExpFilter.prototype,
-
+BlockingFilter.prototype = Object.create(RegExpFilter.prototype, desc({
   type: "blocking",
 
   /**
    * Defines whether the filter should collapse blocked content. Can be null (use the global preference).
    * @type Boolean
    */
   collapse: null
-};
+}));
 
 /**
  * Class for whitelist filters
  * @param {String} text see Filter()
  * @param {String} regexpSource see RegExpFilter()
  * @param {Number} contentType see RegExpFilter()
  * @param {Boolean} matchCase see RegExpFilter()
  * @param {String} domains see RegExpFilter()
  * @param {Boolean} thirdParty see RegExpFilter()
  * @param {String} sitekeys see RegExpFilter()
  * @constructor
  * @augments RegExpFilter
  */
 function WhitelistFilter(text, regexpSource, contentType, matchCase, domains, thirdParty, sitekeys)
 {
   RegExpFilter.call(this, text, regexpSource, contentType, matchCase, domains, thirdParty, sitekeys);
 }
 exports.WhitelistFilter = WhitelistFilter;
 
-WhitelistFilter.prototype =
-{
-  __proto__: RegExpFilter.prototype,
-
+WhitelistFilter.prototype = Object.create(RegExpFilter.prototype, desc({
   type: "whitelist"
-};
+}));
 
 /**
  * Base class for element hiding filters
  * @param {String} text see Filter()
  * @param {String} [domains] Host names or domains the filter should be restricted to
  * @param {String} selector   CSS selector for the HTML elements that should be hidden
  * @constructor
  * @augments ActiveFilter
  */
 function ElemHideBase(text, domains, selector)
 {
   ActiveFilter.call(this, text, domains || null);
 
   if (domains)
     this.selectorDomain = domains.replace(/,~[^,]+/g, "").replace(/^~[^,]+,?/, "").toLowerCase();
   this.selector = selector;
 }
 exports.ElemHideBase = ElemHideBase;
 
-ElemHideBase.prototype =
-{
-  __proto__: ActiveFilter.prototype,
-
+ElemHideBase.prototype = Object.create(ActiveFilter.prototype, desc({
   /**
    * @see ActiveFilter.domainSeparator
    */
   domainSeparator: ",",
 
   /**
    * @see ActiveFilter.ignoreTrailingDot
    */
   ignoreTrailingDot: false,
 
   /**
    * Host name or domain the filter should be restricted to (can be null for no restriction)
    * @type String
    */
   selectorDomain: null,
   /**
    * CSS selector for the HTML elements that should be hidden
    * @type String
    */
   selector: null
-};
+}));
 
 /**
  * Creates an element hiding filter from a pre-parsed text representation
  *
  * @param {String} text         same as in Filter()
  * @param {String} domain       domain part of the text representation (can be empty)
  * @param {Boolean} isException exception rule indicator
  * @param {String} tagName      tag name part (can be empty)
  * @param {String} attrRules    attribute matching rules (can be empty)
  * @param {String} selector     raw CSS selector (can be empty)
@@ skipping 64 matching lines @@
  * @param {String} selector see ElemHideBase()
  * @constructor
  * @augments ElemHideBase
  */
 function ElemHideFilter(text, domains, selector)
 {
   ElemHideBase.call(this, text, domains, selector);
 }
 exports.ElemHideFilter = ElemHideFilter;
 
-ElemHideFilter.prototype =
-{
-  __proto__: ElemHideBase.prototype,
-
+ElemHideFilter.prototype = Object.create(ElemHideBase.prototype, desc({
   type: "elemhide"
-};
+}));
 
 /**
  * Class for element hiding exceptions
  * @param {String} text see Filter()
  * @param {String} domains  see ElemHideBase()
  * @param {String} selector see ElemHideBase()
  * @constructor
  * @augments ElemHideBase
  */
 function ElemHideException(text, domains, selector)
 {
   ElemHideBase.call(this, text, domains, selector);
 }
 exports.ElemHideException = ElemHideException;
 
-ElemHideException.prototype =
-{
-  __proto__: ElemHideBase.prototype,
-
+ElemHideException.prototype = Object.create(ElemHideBase.prototype, desc({
   type: "elemhideexception"
-};
+}));
 
 /**
  * Class for CSS property filters
  * @param {String} text           see Filter()
  * @param {String} domains        see ElemHideBase()
  * @param {String} selector       see ElemHideBase()
  * @param {String} regexpSource   see CSSPropertyFilter.regexpSource
  * @param {String} selectorPrefix see CSSPropertyFilter.selectorPrefix
  * @param {String} selectorSuffix see CSSPropertyFilter.selectorSuffix
  * @constructor
  * @augments ElemHideBase
  */
 function CSSPropertyFilter(text, domains, selector, regexpSource,
   selectorPrefix, selectorSuffix)
 {
   ElemHideBase.call(this, text, domains, selector);
 
   this.regexpSource = regexpSource;
   this.selectorPrefix = selectorPrefix;
   this.selectorSuffix = selectorSuffix;
 }
 exports.CSSPropertyFilter = CSSPropertyFilter;
 
-CSSPropertyFilter.prototype =
-{
-  __proto__: ElemHideBase.prototype,
-
+CSSPropertyFilter.prototype = Object.create(ElemHideBase.prototype, desc({
   type: "cssproperty",
 
   /**
    * Expression from which a regular expression should be generated for matching
    * CSS properties - for delayed creation of the regexpString property
    * @type String
    */
   regexpSource: null,
   /**
    * Substring of CSS selector before properties for the HTML elements that
    * should be hidden
    * @type String
    */
   selectorPrefix: null,
   /**
    * Substring of CSS selector after properties for the HTML elements that
    * should be hidden
    * @type String
    */
   selectorSuffix: null,
 
   /**
    * Raw regular expression string to be used when testing CSS properties
    * against this filter
    * @type String
    */
-  get regexpString()
-  {
-    // Despite this property being cached, the getter is called
-    // several times on Safari, due to WebKit bug 132872
-    let prop = Object.getOwnPropertyDescriptor(this, "regexpString");
-    if (prop)
-      return prop.value;
+  regexpString: {
+    get: function()
+    {
+      // Despite this property being cached, the getter is called
+      // several times on Safari, due to WebKit bug 132872
+      let prop = Object.getOwnPropertyDescriptor(this, "regexpString");
+      if (prop)
+        return prop.value;
 
-    let regexp = Filter.toRegExp(this.regexpSource);
-    Object.defineProperty(this, "regexpString", {value: regexp});
-    return regexp;
+      let regexp = Filter.toRegExp(this.regexpSource);
+      Object.defineProperty(this, "regexpString", {value: regexp});
+      return regexp;
+    }
   }
-};
+}));