Issue 4329 - Add $generichide support

lib/abp2blocklist.js

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2017 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 344 matching lines @@
  * Create a new Adblock Plus filter to content blocker list converter
  *
  * @constructor
  */
 exports.ContentBlockerList = function ()
 {
   this.requestFilters = [];
   this.requestExceptions = [];
   this.elemhideFilters = [];
   this.elemhideExceptions =  [];
+  this.generichideExceptions = [];
   this.elemhideSelectorExceptions = new Map();
 };
 
 /**
  * Add Adblock Plus filter to be converted
  *
  * @param {Filter} filter Filter to convert
  */
 ContentBlockerList.prototype.addFilter = function(filter)
 {
   if (filter.sitekeys)
     return;
   if (filter instanceof filterClasses.RegExpFilter &&
       filter.regexpSource == null)
     return;
 
   if (filter instanceof filterClasses.BlockingFilter)
     this.requestFilters.push(filter);
 
   if (filter instanceof filterClasses.WhitelistFilter)
   {
     if (filter.contentType & (typeMap.DOCUMENT | whitelistableRequestTypes))
       this.requestExceptions.push(filter);
 
       if (filter.contentType & typeMap.ELEMHIDE)
         this.elemhideExceptions.push(filter);
+      else if (filter.contentType & typeMap.GENERICHIDE)
+        this.generichideExceptions.push(filter);
   }
 
   if (filter instanceof filterClasses.ElemHideFilter)
     this.elemhideFilters.push(filter);
 
   if (filter instanceof filterClasses.ElemHideException)
   {
     let domains = this.elemhideSelectorExceptions[filter.selector];
     if (!domains)
       domains = this.elemhideSelectorExceptions[filter.selector] = [];
 
     parseDomains(filter.domains, domains, []);
   }
 };
 
 /**
  * Generate content blocker list for all filters that were added
  *
  * @returns   {Filter}   filter    Filter to convert
  */
 ContentBlockerList.prototype.generateRules = function(filter)
 {
   let rules = [];
 
   let groupedElemhideFilters = new Map();
+
+  // Make sure the generic element hiding filters are first in the map so they
+  // get generated first.
+  groupedElemhideFilters.set("^https?://", []);

[Sebastian Noack, 2017/05/17 06:37:10]

I'm not sure if it is a good idea, to split up generic and domain-specific
filters based on their output, relying on their url-pattern, hard-coding it in 3
places.

How about splitting up the elemhideFilters array into two, one for generic and
one for domain-specific filters, distinguishing them while they are parsed?

+
   for (let filter of this.elemhideFilters)
   {
     let result = convertElemHideFilter(filter, this.elemhideSelectorExceptions);
     if (!result)
       continue;
 
     if (result.matchDomains.length == 0)
       result.matchDomains = ["^https?://"];
 
     for (let matchDomain of result.matchDomains)
@@ skipping 14 matching lines @@
       // this by converting to the attribute format [id="elementID"]
       selector = convertIDSelectorsToAttributeSelectors(selector);
 
       rules.push({
         trigger: {"url-filter": matchDomain,
                   "url-filter-is-case-sensitive": true},
         action: {type: "css-display-none",
                  selector: selector}
       });
     }
+
+    if (matchDomain == "^https?://")
+    {
+      // Right after the generic element hiding filters, add the exceptions
+      // that should apply only to those filters.
+      for (let filter of this.generichideExceptions)
+        convertFilterAddRules(rules, filter, "ignore-previous-rules", false);
+    }
   });
 
   for (let filter of this.elemhideExceptions)
     convertFilterAddRules(rules, filter, "ignore-previous-rules", false);
   for (let filter of this.requestFilters)
     convertFilterAddRules(rules, filter, "block", true);
   for (let filter of this.requestExceptions)
     convertFilterAddRules(rules, filter, "ignore-previous-rules", true);
 
   return rules.filter(rule => !hasNonASCI(rule));
 };