Issue 5042 - Adds handling for requests which are not associated with browser tab

lib/requestBlocker.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 requestBlocker */
 
 "use strict";
 
 const {Filter, RegExpFilter, BlockingFilter} = require("filterClasses");
 const {Subscription} = require("subscriptionClasses");
 const {defaultMatcher} = require("matcher");
 const {FilterNotifier} = require("filterNotifier");
 const {Prefs} = require("prefs");
 const {checkWhitelisted, getKey} = require("whitelisting");
-const {stringifyURL, getDecodedHostname,
-      extractHostFromFrame, isThirdParty} = require("url");
+const {stringifyURL, extractHostFromFrame, isThirdParty} = require("url");
 const {port} = require("messaging");
 const devtools = require("devtools");
 
-// Chrome can't distinguish between OBJECT_SUBREQUEST and OBJECT requests.
+// Chrome and Firefox (WebExtensions) can't distinguish between
+// OBJECT_SUBREQUEST and OBJECT requests.
 RegExpFilter.typeMap.OBJECT_SUBREQUEST = RegExpFilter.typeMap.OBJECT;
+
+// Map of content types reported by the browser to the respecitve content types
+// used by Adblock Plus. Other content types are simply mapped to OTHER.
+let resourceTypes = new Map(function*()
+{
+  for (let type in RegExpFilter.typeMap)
+    yield [type.toLowerCase(), type];
+
+  yield ["sub_frame", "SUBDOCUMENT"];
+
+  // Treat navigator.sendBeacon() the same as <a ping>, it's essentially the
+  // same concept - merely generalized.
+  yield ["beacon", "PING"];
+
+  // Treat <img srcset> and <picture> the same as other images.
+  yield ["imageset", "IMAGE"];
+}());
 
 function onBeforeRequestAsync(page, url, type, docDomain,
                               thirdParty, sitekey,
                               specificOnly, filter)
 {
   if (filter)
     FilterNotifier.emit("filter.hitCount", filter, 0, 0, page);
 
   if (devtools)
   {
     devtools.logRequest(
       page, url, type, docDomain,
       thirdParty, sitekey,
       specificOnly, filter
     );
   }
 }
 
 ext.webRequest.onBeforeRequest.addListener((url, type, page, frame) =>
 {
-  let docDomain = getDecodedHostname(url);

[Sebastian Noack, 2017/04/21 08:39:53]

Is there a reason you derive the parent document's domain from the request URL?
Note that these makes requests that don't have an associated tab
indistinguishable from those that that have (in the devtools panel). Also it
seems incorrect, as *$domain=example.com is supposed to match subrequests from
documents served from example.com, not requests that are served from example.com
in documents served from other domains.

[Jon Sonesen, 2017/04/24 08:40:56]

I see, I misunderstood what I was doing here. I just saw that the docDomain was
being defined before but was not sure how to fetch it without the page variable
and saw that the docDomain can also be obtained via the getDecodedHostname
function. So what is the best option here? Should I just set the domain as the
URL?

+  let docDomain = null;
   let sitekey = null;
+  let specificOnly = false;
+  let thirdParty = false;
+  let urlString = stringifyURL(url);
+
+
   if (frame && page)
   {
     if (checkWhitelisted(page, frame))
       return true;
+
     docDomain = extractHostFromFrame(frame);
     sitekey = getKey(page, frame);
+    thirdParty = isThirdParty(url, docDomain);
+    specificOnly = !!checkWhitelisted(page, frame,
+                                      RegExpFilter.typeMap.GENERICBLOCK);
   }
 
-  let urlString = stringifyURL(url);
-  let thirdParty = isThirdParty(url, docDomain);
-
-  let specificOnly = !!checkWhitelisted(
-    page, frame, RegExpFilter.typeMap.GENERICBLOCK
-  );
+  let mappedType = resourceTypes.get(type) || "OTHER";
 
   let filter = defaultMatcher.matchesAny(
-    urlString, RegExpFilter.typeMap[type],
+    urlString, RegExpFilter.typeMap[mappedType],
     docDomain, thirdParty, sitekey, specificOnly
   );
 
   setTimeout(onBeforeRequestAsync, 0, page, urlString,
-                                      type, docDomain,
+                                      mappedType, docDomain,
                                       thirdParty, sitekey,
                                       specificOnly, filter);
 
   return !(filter instanceof BlockingFilter);
 });
 
 port.on("filters.collapse", (message, sender) =>
 {
   if (checkWhitelisted(sender.page, sender.frame))
     return false;
@@ skipping 69 matching lines @@
 FilterNotifier.on("filter.added", onFilterChange);
 FilterNotifier.on("filter.removed", onFilterChange);
 FilterNotifier.on("filter.disabled", arg => onFilterChange(arg, true));
 FilterNotifier.on("load", onFilterChange);
 
 port.on("request.blockedByWrapper", (msg, sender) =>
 {
   // Chrome 58 onwards directly supports WebSocket blocking, so we can ignore
   // messages from the wrapper here (see https://crbug.com/129353). Hopefully
   // WebRTC will be supported soon too (see https://crbug.com/707683).
-  if (msg.requestType in chrome.webRequest.ResourceType)
+  if (msg.requestType.toUpperCase() in chrome.webRequest.ResourceType)
     return false;
 
   return ext.webRequest.onBeforeRequest._dispatch(
      new URL(msg.url),
      msg.requestType,
      sender.page,
      sender.frame
   ).includes(false);
 });