Issue 5283 - Combine other raw types with WebSocket and WebRTC when possible

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
  * 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/>.
  */
 
 /** @module abp2blocklist */
 
 "use strict";
 
 let filterClasses = require("filterClasses");
 let punycode = require("punycode");
 
 const selectorLimit = 5000;
 const typeMap = filterClasses.RegExpFilter.typeMap;
-const whitelistableRequestTypes = (typeMap.IMAGE
-                                   | typeMap.STYLESHEET
-                                   | typeMap.SCRIPT
-                                   | typeMap.FONT
-                                   | typeMap.MEDIA
-                                   | typeMap.POPUP
-                                   | typeMap.OBJECT
-                                   | typeMap.OBJECT_SUBREQUEST
-                                   | typeMap.XMLHTTPREQUEST
-                                   | typeMap.WEBSOCKET
-                                   | typeMap.WEBRTC
-                                   | typeMap.PING
-                                   | typeMap.SUBDOCUMENT
-                                   | typeMap.OTHER);
+
+const httpRequestTypes = typeMap.IMAGE |
+                         typeMap.STYLESHEET |
+                         typeMap.SCRIPT |
+                         typeMap.FONT |
+                         typeMap.MEDIA |
+                         typeMap.POPUP |
+                         typeMap.OBJECT |
+                         typeMap.OBJECT_SUBREQUEST |
+                         typeMap.XMLHTTPREQUEST |
+                         typeMap.PING |
+                         typeMap.SUBDOCUMENT |
+                         typeMap.OTHER;
+const rawRequestTypes = typeMap.XMLHTTPREQUEST |
+                        typeMap.WEBSOCKET |
+                        typeMap.WEBRTC |
+                        typeMap.OBJECT_SUBREQUEST |
+                        typeMap.PING |
+                        typeMap.OTHER;
+const whitelistableRequestTypes = httpRequestTypes |
+                                  typeMap.WEBSOCKET |
+                                  typeMap.WEBRTC;
 
 function parseDomains(domains, included, excluded)
 {
   for (let domain in domains)
   {
     if (domain != "")
     {
       let enabled = domains[domain];
       domain = punycode.toASCII(domain.toLowerCase());
 
@@ skipping 16 matching lines @@
 }
 
 function getURLSchemes(contentType)
 {
   // If the given content type includes all supported URL schemes, simply
   // return a single generic URL scheme pattern. This minimizes the size of the
   // generated rule set. The downside to this is that it will also match
   // schemes that we do not want to match (e.g. "ftp://"), but this can be
   // mitigated by adding exceptions for those schemes.
   if (contentType & typeMap.WEBSOCKET && contentType & typeMap.WEBRTC &&
-      contentType & ~(typeMap.WEBSOCKET | typeMap.WEBRTC))
+      contentType & httpRequestTypes)
     return ["[^:]+:(//)?"];
 
   let urlSchemes = [];
 
   if (contentType & typeMap.WEBSOCKET)
     urlSchemes.push("wss?://");
 
   if (contentType & typeMap.WEBRTC)
     urlSchemes.push("stuns?:", "turns?:");
 
-  if (contentType & ~(typeMap.WEBSOCKET | typeMap.WEBRTC))
+  if (contentType & httpRequestTypes)
     urlSchemes.push("https?://");
 
   return urlSchemes;
 }
 
 function findSubdomainsInList(domain, list)
 {
   let subdomains = [];
   let suffixLength = domain.length + 1;
 
@@ skipping 182 matching lines @@
   if (contentType & typeMap.STYLESHEET)
     types.push("style-sheet");
   if (contentType & typeMap.SCRIPT)
     types.push("script");
   if (contentType & typeMap.FONT)
     types.push("font");
   if (contentType & (typeMap.MEDIA | typeMap.OBJECT))
     types.push("media");
   if (contentType & typeMap.POPUP)
     types.push("popup");
-  if (contentType & (typeMap.XMLHTTPREQUEST |
-                     typeMap.WEBSOCKET |
-                     typeMap.WEBRTC |
-                     typeMap.OBJECT_SUBREQUEST |
-                     typeMap.PING |
-                     typeMap.OTHER))
-  {
+  if (contentType & rawRequestTypes)
     types.push("raw");
-  }
   if (contentType & typeMap.SUBDOCUMENT)
     types.push("document");
 
   return types;
 }
 
 function makeRuleCopies(trigger, action, urlSchemes)
 {
   let copies = [];
 
@@ skipping 34 matching lines @@
     trigger["top-url-filter-is-case-sensitive"] = true;
 }
 
 function convertFilterAddRules(rules, filter, action, withResourceTypes,
                                exceptionDomains, contentType)
 {
   if (!contentType)
     contentType = filter.contentType;
 
   // If WebSocket or WebRTC are given along with other options but not
-  // including all three of WebSocket, WebRTC, and XMLHttpRequest, we must
-  // generate multiple rules. For example, for the filter
+  // including all three of WebSocket, WebRTC, and at least one HTTP raw type,
+  // we must generate multiple rules. For example, for the filter
   // "foo$websocket,image", we must generate one rule with "^wss?://" and "raw"
   // and another rule with "^https?://" and "image". If we merge the two, we
-  // end up blocking requests of type XMLHttpRequest inadvertently.
+  // end up blocking requests of all HTTP raw types (e.g. XMLHttpRequest)
+  // inadvertently.
   if ((contentType & typeMap.WEBSOCKET && contentType != typeMap.WEBSOCKET &&
        !(contentType & typeMap.WEBRTC &&
-         contentType & typeMap.XMLHTTPREQUEST)) ||
+         contentType & rawRequestTypes & httpRequestTypes)) ||
       (contentType & typeMap.WEBRTC && contentType != typeMap.WEBRTC &&
        !(contentType & typeMap.WEBSOCKET &&
-         contentType & typeMap.XMLHTTPREQUEST)))
+         contentType & rawRequestTypes & httpRequestTypes)))
   {
     if (contentType & typeMap.WEBSOCKET)
     {
       convertFilterAddRules(rules, filter, action, withResourceTypes,
                             exceptionDomains, typeMap.WEBSOCKET);
     }
 
     if (contentType & typeMap.WEBRTC)
     {
       convertFilterAddRules(rules, filter, action, withResourceTypes,
@@ skipping 371 matching lines @@
   {
     convertFilterAddRules(rules, filter, "block", true,
                           requestFilterExceptionDomains);
   }
 
   for (let filter of this.requestExceptions)
     convertFilterAddRules(rules, filter, "ignore-previous-rules", true);
 
   return rules;
 };