Issue [TBD] - Update adblockpluscore dependency to [TBD]

lib/requestBlocker.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
  * 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("../adblockpluscore/lib/filterClasses");
 const {Subscription} = require("../adblockpluscore/lib/subscriptionClasses");
 const {defaultMatcher} = require("../adblockpluscore/lib/matcher");
 const {filterNotifier} = require("../adblockpluscore/lib/filterNotifier");
-const {isThirdParty} = require("../adblockpluscore/lib/domain");
 const {Prefs} = require("./prefs");
 const {checkWhitelisted, getKey} = require("./whitelisting");
 const {extractHostFromFrame} = require("./url");
 const {port} = require("./messaging");
 const {logRequest: hitLoggerLogRequest} = require("./hitLogger");
 
 const extensionProtocol = new URL(browser.extension.getURL("")).protocol;
 
 // Chrome can't distinguish between OBJECT_SUBREQUEST and OBJECT requests.
 if (!browser.webRequest.ResourceType ||
@@ skipping 43 matching lines @@
 function getDocumentInfo(page, frame, originUrl)
 {
   return [
     extractHostFromFrame(frame, originUrl),
     getKey(page, frame, originUrl),
     !!checkWhitelisted(page, frame, originUrl,
                        RegExpFilter.typeMap.GENERICBLOCK)
   ];
 }
 
-function matchRequest(url, type, docDomain, sitekey, specificOnly)
-{
-  let thirdParty = isThirdParty(url, docDomain);
-  let filter = defaultMatcher.matchesAny(url.href, RegExpFilter.typeMap[type],
-                                         docDomain, thirdParty,
-                                         sitekey, specificOnly);
-  return [filter, thirdParty];
-}
-
 function getRelatedTabIds(details)
 {
   // This is the common case, the request is associated with a single tab.
   // If tabId is -1, its not (e.g. the request was sent by
   // a Service/Shared Worker) and we have to identify the related tabs.
   if (details.tabId != -1)
     return Promise.resolve([details.tabId]);
 
   let url;                    // Firefox provides "originUrl" indicating the
   if (details.originUrl)      // URL of the tab that caused this request.
@@ skipping 71 matching lines @@
   // this can also indicate a request sent by a Shared/Service Worker).
   if (!frame && !originUrl)
     return;
 
   if (checkWhitelisted(page, frame, originUrl))
     return;
 
   let type = resourceTypes.get(details.type) || "OTHER";
   let [docDomain, sitekey, specificOnly] = getDocumentInfo(page, frame,
                                                            originUrl);
-  let [filter, thirdParty] = matchRequest(url, type, docDomain,
-                                          sitekey, specificOnly);
+  let filter = defaultMatcher.matchesAny(url, RegExpFilter.typeMap[type],
+                                         docDomain, sitekey, specificOnly);
 
   let result;
   let rewrittenUrl;
 
   if (filter instanceof BlockingFilter)
   {
     if (typeof filter.rewrite == "string")
     {
       rewrittenUrl = filter.rewriteUrl(details.url);
       // If no rewrite happened (error, different origin), we'll
       // return undefined in order to avoid an "infinite" loop.
       if (rewrittenUrl != details.url)
         result = {redirectUrl: rewrittenUrl};
     }
     else
       result = {cancel: true};
   }
 
   getRelatedTabIds(details).then(tabIds =>
   {
     logRequest(
       tabIds,
       {
-        url: details.url, type, docDomain, thirdParty,
+        url: details.url, type, docDomain,
         sitekey, specificOnly, rewrittenUrl
       },
       filter
     );
   });
 
   return result;
 }, {urls: ["<all_urls>"]}, ["blocking"]);
 
 port.on("filters.collapse", (message, sender) =>
 {
   let {page, frame} = sender;
 
   if (checkWhitelisted(page, frame))
     return false;
 
   let blocked = false;
   let [docDomain, sitekey, specificOnly] = getDocumentInfo(page, frame);
 
   for (let url of message.urls)
   {
-    let [filter] = matchRequest(new URL(url, message.baseURL),
-                                message.mediatype, docDomain,
-                                sitekey, specificOnly);
+    let filter = defaultMatcher.matchesAny(new URL(url, message.baseURL),
+                                           RegExpFilter.typeMap[message.mediatype],
+                                           docDomain, sitekey, specificOnly);
 
     if (filter instanceof BlockingFilter)
     {
       if (filter.collapse != null)
         return filter.collapse;
       blocked = true;
     }
   }
 
   return blocked && Prefs.hidePlaceholders;
 });
 
 port.on("request.blockedByRTCWrapper", (msg, sender) =>
 {
   let {page, frame} = sender;
 
   if (checkWhitelisted(page, frame))
     return false;
 
   let {url} = msg;
   let [docDomain, sitekey, specificOnly] = getDocumentInfo(page, frame);
-  let [filter, thirdParty] = matchRequest(new URL(url), "WEBRTC", docDomain,
-                                          sitekey, specificOnly);
+  let filter = defaultMatcher.matchesAny(new URL(url),
+                                         RegExpFilter.typeMap.WEBRTC,
+                                         docDomain, sitekey, specificOnly);
   logRequest(
     [sender.page.id],
-    {url, type: "WEBRTC", docDomain, thirdParty, sitekey, specificOnly},
+    {url, type: "WEBRTC", docDomain, sitekey, specificOnly},
     filter
   );
 
   return filter instanceof BlockingFilter;
 });
 
 let ignoreFilterNotifications = false;
 let handlerBehaviorChangedQuota =
   browser.webRequest.MAX_HANDLER_BEHAVIOR_CHANGED_CALLS_PER_10_MINUTES;
 
@@ skipping 53 matching lines @@
 }
 
 filterNotifier.on("subscription.added", onFilterChange);
 filterNotifier.on("subscription.removed", arg => onFilterChange(arg, false));
 filterNotifier.on("subscription.updated", onFilterChange);
 filterNotifier.on("subscription.disabled", arg => onFilterChange(arg, true));
 filterNotifier.on("filter.added", onFilterChange);
 filterNotifier.on("filter.removed", onFilterChange);
 filterNotifier.on("filter.disabled", arg => onFilterChange(arg, true));
 filterNotifier.on("load", onFilterChange);