Issue 6745 - Prefer strict equality operator

lib/filterClasses.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 118 matching lines @@
       let expression = propsMatch[2];
       let suffix = match[3].substr(propsMatch.index + propsMatch[0].length);
       return Filter.fromText(`${match[1]}#?#` +
           `${prefix}:-abp-properties(${expression})${suffix}`);
     }
 
     filter = ElemHideBase.fromText(
       text, match[1], match[2], match[3]
     );
   }
-  else if (text[0] == "!")
+  else if (text[0] === "!")
     filter = new CommentFilter(text);
   else
     filter = RegExpFilter.fromText(text);
 
   Filter.knownFilters.set(filter.text, filter);
   return filter;
 };
 
 /**
  * Deserializes a filter
  *
  * @param {Object}  obj map of serialized properties and their values
  * @return {Filter} filter or null if the filter couldn't be created
  */
 Filter.fromObject = function(obj)
 {
   let filter = Filter.fromText(obj.text);
   if (filter instanceof ActiveFilter)
   {
     if ("disabled" in obj)
-      filter._disabled = (obj.disabled == "true");
+      filter._disabled = (obj.disabled === "true");
     if ("hitCount" in obj)
       filter._hitCount = parseInt(obj.hitCount, 10) || 0;
     if ("lastHit" in obj)
       filter._lastHit = parseInt(obj.lastHit, 10) || 0;
   }
   return filter;
 };
 
 /**
  * Removes unnecessary whitespaces from filter text, will only return null if
@@ skipping 34 matching lines @@
   // For $csp filters we must first separate out the options part of the
   // text, being careful to preserve its spaces.
   let beforeOptions = strippedText.substring(0, optionsMatch.index);
   let strippedDollarIndex = -1;
   let dollarIndex = -1;
   do
   {
     strippedDollarIndex = beforeOptions.indexOf("$", strippedDollarIndex + 1);
     dollarIndex = text.indexOf("$", dollarIndex + 1);
   }
-  while (strippedDollarIndex != -1);
+  while (strippedDollarIndex !== -1);
   let optionsText = text.substr(dollarIndex + 1);
 
   // Then we can normalize spaces in the options part safely
   let options = optionsText.split(",");
   for (let i = 0; i < options.length; i++)
   {
     let option = options[i];
     let cspMatch = /^ *c *s *p *=/i.exec(option);
     if (cspMatch)
     {
@@ skipping 92 matching lines @@
   /**
    * Defines whether the filter is disabled
    * @type {boolean}
    */
   get disabled()
   {
     return this._disabled;
   },
   set disabled(value)
   {
-    if (value != this._disabled)
+    if (value !== this._disabled)
     {
       let oldValue = this._disabled;
       this._disabled = value;
       FilterNotifier.triggerListeners("filter.disabled", this, value, oldValue);
     }
     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)
+    if (value !== this._hitCount)
     {
       let oldValue = this._hitCount;
       this._hitCount = value;
       FilterNotifier.triggerListeners("filter.hitCount", this, value, oldValue);
     }
     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)
+    if (value !== this._lastHit)
     {
       let oldValue = this._lastHit;
       this._lastHit = value;
       FilterNotifier.triggerListeners("filter.lastHit", this, value, oldValue);
     }
     return this._lastHit;
   },
 
   /**
    * String that the domains property should be generated from
@@ skipping 26 matching lines @@
 
     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 (list.length === 1 && list[0][0] !== "~")
       {
         // Fast track for the common one-domain scenario
         domains = new Map([["", false], [list[0], true]]);
       }
       else
       {
         let hasIncludes = false;
         for (let i = 0; i < list.length; i++)
         {
           let domain = list[i];
-          if (domain == "")
+          if (domain === "")
             continue;
 
           let include;
-          if (domain[0] == "~")
+          if (domain[0] === "~")
           {
             include = false;
             domain = domain.substr(1);
           }
           else
           {
             include = true;
             hasIncludes = true;
           }
 
@@ skipping 43 matching lines @@
     // If the document has no host name, match only if the filter
     // isn't restricted to specific domains
     if (!docDomain)
       return this.domains.get("");
 
     docDomain = docDomain.replace(/\.+$/, "").toUpperCase();
 
     while (true)
     {
       let isDomainIncluded = this.domains.get(docDomain);
-      if (typeof isDomainIncluded != "undefined")
+      if (typeof isDomainIncluded !== "undefined")
         return isDomainIncluded;
 
       let nextDot = docDomain.indexOf(".");
       if (nextDot < 0)
         break;
       docDomain = docDomain.substr(nextDot + 1);
     }
     return this.domains.get("");
   },
 
   /**
    * Checks whether this filter is active only on a domain and its subdomains.
    * @param {string} docDomain
    * @return {boolean}
    */
   isActiveOnlyOnDomain(docDomain)
   {
     if (!docDomain || !this.domains || this.domains.get(""))
       return false;
 
     docDomain = docDomain.replace(/\.+$/, "").toUpperCase();
 
     for (let [domain, isIncluded] of this.domains)
     {
-      if (isIncluded && domain != docDomain)
+      if (isIncluded && domain !== docDomain)
       {
         if (domain.length <= docDomain.length)
           return false;
 
         if (!domain.endsWith("." + docDomain))
           return false;
       }
     }
 
     return true;
@@ skipping 47 matching lines @@
  * @param {string} [sitekeys]
  *   Public keys of websites that this filter should apply to
  * @constructor
  * @augments ActiveFilter
  */
 function RegExpFilter(text, regexpSource, contentType, matchCase, domains,
                       thirdParty, sitekeys)
 {
   ActiveFilter.call(this, text, domains, sitekeys);
 
-  if (contentType != null)
+  if (contentType !== null)
     this.contentType = contentType;
   if (matchCase)
     this.matchCase = matchCase;
-  if (thirdParty != null)
+  if (thirdParty !== null)
     this.thirdParty = thirdParty;
-  if (sitekeys != null)
+  if (sitekeys !== null)
     this.sitekeySource = sitekeys;
 
   if (regexpSource.length >= 2 &&
-      regexpSource[0] == "/" &&
-      regexpSource[regexpSource.length - 1] == "/")
+      regexpSource[0] === "/" &&
+      regexpSource[regexpSource.length - 1] === "/")
   {
     // The filter is a regular expression - convert it immediately to
     // catch syntax errors
     let regexp = new RegExp(regexpSource.substr(1, regexpSource.length - 2),
                             this.matchCase ? "" : "i");
     Object.defineProperty(this, "regexp", {value: regexp});
   }
   else
   {
     // No need to convert this filter to regular expression yet, do it on demand
@@ skipping 88 matching lines @@
    * @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(location, typeMask, docDomain, thirdParty, sitekey)
   {
     if (this.contentType & typeMask &&
-        (this.thirdParty == null || this.thirdParty == thirdParty) &&
+        (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
 Object.defineProperty(RegExpFilter.prototype, "0", {
   get() { return this; }
 });
 
 /**
  * Creates a RegExp filter from its text representation
  * @param {string} text   same as in Filter()
  * @return {Filter}
  */
 RegExpFilter.fromText = function(text)
 {
   let blocking = true;
   let origText = text;
-  if (text[0] == "@" && text[1] == "@")
+  if (text[0] === "@" && text[1] === "@")
   {
     blocking = false;
     text = text.substr(2);
   }
 
   let contentType = null;
   let matchCase = null;
   let domains = null;
   let sitekeys = null;
   let thirdParty = null;
@@ skipping 13 matching lines @@
       if (separatorIndex >= 0)
       {
         value = option.substr(separatorIndex + 1);
         option = option.substr(0, separatorIndex);
       }
       option = option.replace(/-/, "_").toUpperCase();
       if (option in RegExpFilter.typeMap)
       {
         contentType |= RegExpFilter.typeMap[option];
 
-        if (option == "CSP" && value)
+        if (option === "CSP" && value)
           csp = value;
       }
-      else if (option[0] == "~" && option.substr(1) in RegExpFilter.typeMap)
+      else if (option[0] === "~" && option.substr(1) in RegExpFilter.typeMap)
       {
-        if (contentType == null)
+        if (contentType === null)
           ({contentType} = RegExpFilter.prototype);
         contentType &= ~RegExpFilter.typeMap[option.substr(1)];
       }
-      else if (option == "MATCH_CASE")
+      else if (option === "MATCH_CASE")
         matchCase = true;
-      else if (option == "~MATCH_CASE")
+      else if (option === "~MATCH_CASE")
         matchCase = false;
-      else if (option == "DOMAIN" && value)
+      else if (option === "DOMAIN" && value)
         domains = value.toUpperCase();
-      else if (option == "THIRD_PARTY")
+      else if (option === "THIRD_PARTY")
         thirdParty = true;
-      else if (option == "~THIRD_PARTY")
+      else if (option === "~THIRD_PARTY")
         thirdParty = false;
-      else if (option == "COLLAPSE")
+      else if (option === "COLLAPSE")
         collapse = true;
-      else if (option == "~COLLAPSE")
+      else if (option === "~COLLAPSE")
         collapse = false;
-      else if (option == "SITEKEY" && value)
+      else if (option === "SITEKEY" && value)
         sitekeys = value.toUpperCase();
-      else if (option == "REWRITE" && value)
+      else if (option === "REWRITE" && value)
         rewrite = value;
       else
         return new InvalidFilter(origText, "filter_unknown_option");
     }
   }
 
   // For security reasons, never match $rewrite filters
   // against requests that might load any code to be executed.
-  if (rewrite != null)
+  if (rewrite !== null)
   {
-    if (contentType == null)
+    if (contentType === null)
       ({contentType} = RegExpFilter.prototype);
     contentType &= ~(RegExpFilter.typeMap.SCRIPT |
                      RegExpFilter.typeMap.SUBDOCUMENT |
                      RegExpFilter.typeMap.OBJECT |
                      RegExpFilter.typeMap.OBJECT_SUBREQUEST);
   }
 
   try
   {
     if (blocking)
@@ skipping 70 matching lines @@
  *   BlockingFilter.prototype.rewrite.
  * @constructor
  * @augments RegExpFilter
  */
 function BlockingFilter(text, regexpSource, contentType, matchCase, domains,
                         thirdParty, sitekeys, collapse, csp, rewrite)
 {
   RegExpFilter.call(this, text, regexpSource, contentType, matchCase, domains,
                     thirdParty, sitekeys);
 
-  if (collapse != null)
+  if (collapse !== null)
     this.collapse = collapse;
 
-  if (csp != null)
+  if (csp !== null)
     this.csp = csp;
 
-  if (rewrite != null)
+  if (rewrite !== null)
     this.rewrite = rewrite;
 }
 exports.BlockingFilter = BlockingFilter;
 
 BlockingFilter.prototype = extend(RegExpFilter, {
   type: "blocking",
 
   /**
    * Defines whether the filter should collapse blocked content.
    * Can be null (use the global preference).
@@ skipping 17 matching lines @@
   /**
    * Rewrites an URL.
    * @param {string} url the URL to rewrite
    * @return {string} the rewritten URL, or the original in case of failure
    */
   rewriteUrl(url)
   {
     try
     {
       let rewrittenUrl = new URL(url.replace(this.regexp, this.rewrite), url);
-      if (rewrittenUrl.origin == new URL(url).origin)
+      if (rewrittenUrl.origin === new URL(url).origin)
         return rewrittenUrl.href;
     }
     catch (e)
     {
     }
 
     return url;
   }
 });
 
@@ skipping 66 matching lines @@
  *          ElemHideEmulationFilter|InvalidFilter}
  */
 ElemHideBase.fromText = function(text, domains, type, selector)
 {
   // We don't allow ElemHide filters which have any empty domains.
   // Note: The ElemHide.prototype.domainSeparator is duplicated here, if that
   // changes this must be changed too.
   if (domains && /(^|,)~?(,|$)/.test(domains))
     return new InvalidFilter(text, "filter_invalid_domain");
 
-  if (type == "@")
+  if (type === "@")
     return new ElemHideException(text, domains, selector);
 
-  if (type == "?")
+  if (type === "?")
   {
     // Element hiding emulation filters are inefficient so we need to make sure
     // that they're only applied if they specify active domains
     if (!/,[^~][^,.]*\.[^,]/.test("," + domains))
       return new InvalidFilter(text, "filter_elemhideemulation_nodomain");
 
     return new ElemHideEmulationFilter(text, domains, selector);
   }
 
   return new ElemHideFilter(text, domains, selector);
@@ skipping 45 matching lines @@
  */
 function ElemHideEmulationFilter(text, domains, selector)
 {
   ElemHideBase.call(this, text, domains, selector);
 }
 exports.ElemHideEmulationFilter = ElemHideEmulationFilter;
 
 ElemHideEmulationFilter.prototype = extend(ElemHideBase, {
   type: "elemhideemulation"
 });