Issue 6622 - Implement $rewrite filter option

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
@@ skipping 52 matching lines @@
   if (!(browser.webRequest.ResourceType))
     return;
 
   for (let type in browser.webRequest.ResourceType)
     yield resourceTypes.get(browser.webRequest.ResourceType[type]) || "OTHER";
 
   // WEBRTC gets addressed through a workaround, even if the webRequest API is
   // lacking support to block this kind of a request.
   yield "WEBRTC";
 
-  // POPUP, CSP and ELEMHIDE filters aren't mapped to resource types.
+  // These filter types aren't mapped to resource types.
   yield "POPUP";
   yield "ELEMHIDE";
   yield "CSP";
 }());
 
 function getDocumentInfo(page, frame, originUrl)
 {
   return [
     extractHostFromFrame(frame, originUrl),
     getKey(page, frame, originUrl),
@@ skipping 32 matching lines @@
     url = details.initiator + "/*";  // is equivalent to "originUrl" on Firefox
                                      // except that its not a full URL but just
                                      // an origin (proto + host).
   else
     return Promise.resolve([]);
 
   return browser.tabs.query({url}).then(tabs => tabs.map(tab => tab.id));
 }
 
 function logRequest(tabIds, url, type, docDomain, thirdParty,
-                    sitekey, specificOnly, filter)
+                    sitekey, specificOnly, filter, rewrittenTo)
 {
   if (filter)
     FilterNotifier.emit("filter.hitCount", filter, 0, 0, tabIds);
 
   devtools.logRequest(
     tabIds, url, type, docDomain,
     thirdParty, sitekey,
-    specificOnly, filter
+    specificOnly, filter, rewrittenTo
   );
 }
 
 browser.webRequest.onBeforeRequest.addListener(details =>
 {
   // Never block top-level documents.
   if (details.type == "main_frame")
     return;
 
   // Filter out requests from non web protocols. Ideally, we'd explicitly
@@ skipping 42 matching lines @@
 
   if (checkWhitelisted(page, frame, originUrl))
     return;
 
   let type = resourceTypes.get(details.type) || "OTHER";
   let [docDomain, sitekey, specificOnly] = getDocumentInfo(page, frame,
                                                            originUrl);
   let [filter, urlString, thirdParty] = matchRequest(url, type, docDomain,
                                                      sitekey, specificOnly);
 
+  let result;
+  let rewritten;

[Sebastian Noack, 2018/05/05 13:46:53]

Nit: Since these variables are no always assigned below, we might want to
initialize them here, to make the behavior more explicit, and for consistency
since we never return or pass along uninitialized variables anywhere.

[hub, 2018/05/07 20:13:04]

In both cases they are undefined which is totally fine. return result that is
undefined is what we want if there is nothing to rewrite and if we don't block.

+
+  if (filter instanceof BlockingFilter)
+  {
+    if (filter.rewrite)
+    {
+      rewritten = filter.rewriteUrl(urlString);
+      // if no rewrite happened (error, diff origin), we'll

[Sebastian Noack, 2018/05/05 13:46:53]

Nit: Capitalize first letter of comment (if it is a sentence).

[hub, 2018/05/07 20:13:04]

Done.

+      // return undefined avoid an "infinite" loop.

[Sebastian Noack, 2018/05/05 13:46:53]

Typo: ... in order to avoid ...

[hub, 2018/05/07 20:13:04]

Done.

+      if (rewritten != urlString)
+        result = {redirectUrl: rewritten};
+    }
+    else
+      result = {cancel: true};
+  }
+
   getRelatedTabIds(details).then(tabIds =>
   {
     logRequest(tabIds, urlString, type, docDomain,
-               thirdParty, sitekey, specificOnly, filter);
+               thirdParty, sitekey, specificOnly, filter, rewritten);

[Manish Jethani, 2018/05/05 00:54:12]

For what it's worth, I think we should do the logging part as a separate patch.
For now we can just log it as a regular blocked request.

[Sebastian Noack, 2018/05/05 13:46:53]

Without the logging changes, I consider the resulting behavior of the devtools
panel a regression. So I think we should perform those changes simultaneously.

[hub, 2018/05/07 20:13:04]

Without the UI patch, it will just be logged as a blocked request anyway.

   });
 
-  if (filter instanceof BlockingFilter)
-    return {cancel: true};
+  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;
@@ skipping 94 matching lines @@
 }
 
 FilterNotifier.on("subscription.added", onFilterChange);
 FilterNotifier.on("subscription.removed", onFilterChange);
 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);