Issue 7311 - Split _checkEntryMatchByDomain()

lib/matcher.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 404 matching lines @@
           (count == resultCount && candidate.length > resultLength))
       {
         result = candidate;
         resultCount = count;
         resultLength = candidate.length;
       }
     }
     return result;
   }
 
+  _matchFilterWithoutDomain(filter, location, typeMask, thirdParty, sitekey,
+                            collection)
+  {
+    if (filter.matchesWithoutDomain(location, typeMask, thirdParty, sitekey))
+    {
+      if (!collection)
+        return filter;
+
+      collection.push(filter);
+    }
+
+    return null;
+  }
+
+  _matchFiltersByDomain(filtersByDomain, location, typeMask, docDomain,
+                        thirdParty, sitekey, specificOnly, collection)
+  {
+    let excluded = new Set();
+
+    for (let suffix of domainSuffixes(docDomain ?
+                                        normalizeHostname(docDomain) : "",
+                                      !specificOnly))
+    {
+      let filters = filtersByDomain.get(suffix);
+      if (filters)
+      {
+        for (let [filter, include] of filters.entries())
+        {
+          if (!include)
+          {
+            excluded.add(filter);
+          }
+          else if ((excluded.size == 0 || !excluded.has(filter)) &&
+                   this._matchFilterWithoutDomain(filter, location, typeMask,
+                                                  thirdParty, sitekey,
+                                                  collection))
+          {
+            return filter;
+          }
+        }
+      }
+    }
+
+    return null;
+  }
+
   _checkEntryMatchSimple(keyword, location, typeMask, docDomain, thirdParty,
                          sitekey, specificOnly, collection)
   {
     let filters = this._simpleFiltersByKeyword.get(keyword);
     if (filters)
     {
       let lowerCaseLocation = location.toLowerCase();
 
       for (let filter of filters)
       {
@@ skipping 42 matching lines @@
 
     return null;
   }
 
   _checkEntryMatchByDomain(keyword, location, typeMask, docDomain, thirdParty,
                            sitekey, specificOnly, collection)
   {
     let filtersByDomain = this._filterDomainMapsByKeyword.get(keyword);
     if (filtersByDomain)
     {
+      if (filtersByDomain instanceof Map)
+      {
+        return this._matchFiltersByDomain(filtersByDomain, location, typeMask,
+                                          docDomain, thirdParty, sitekey,
+                                          specificOnly, collection);
+      }
+
       // Because of the memory optimization in the add function, most of the
       // time this will be a filter rather than a map.
-      if (!(filtersByDomain instanceof Map))
-      {
-        if (filtersByDomain.matchesWithoutDomain(location, typeMask,
-                                                 thirdParty, sitekey))
-        {
-          if (!collection)
-            return filtersByDomain;
-
-          collection.push(filtersByDomain);
-        }
-
-        return null;
-      }
-
-      let excluded = new Set();
-
-      for (let suffix of domainSuffixes(docDomain ?
-                                          normalizeHostname(docDomain) : "",
-                                        !specificOnly))
-      {
-        let filters = filtersByDomain.get(suffix);
-        if (filters)
-        {
-          for (let [filter, include] of filters.entries())
-          {
-            if (!include)
-            {
-              excluded.add(filter);
-            }
-            else if ((excluded.size == 0 || !excluded.has(filter)) &&
-                     filter.matchesWithoutDomain(location, typeMask,
-                                                 thirdParty, sitekey))
-            {
-              if (!collection)
-                return filter;
-
-              collection.push(filter);
-            }
-          }
-        }
-      }
+      return this._matchFilterWithoutDomain(filtersByDomain, location,
+                                            typeMask, thirdParty, sitekey,
+                                            collection);
     }
 
     return null;
   }
 
   /**
    * Checks whether the entries for a particular keyword match a URL
    * @param {string} keyword
    * @param {string} location
    * @param {number} typeMask
@@ skipping 336 matching lines @@
 
 exports.CombinedMatcher = CombinedMatcher;
 
 /**
  * Shared {@link CombinedMatcher} instance that should usually be used.
  * @type {CombinedMatcher}
  */
 let defaultMatcher = new CombinedMatcher();
 
 exports.defaultMatcher = defaultMatcher;