Issue 5761 - Changes require paths to relative

messageResponder.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 13 matching lines @@
   const {port} = require("../lib/messaging");
   const {Prefs} = require("../lib/prefs");
   const {Utils} = require("../lib/utils");
   const {FilterStorage} = require("../adblockpluscore/lib/filterStorage");
   const {FilterNotifier} = require("../adblockpluscore/lib/filterNotifier");
   const {defaultMatcher} = require("../adblockpluscore/lib/matcher");
   const {Notification:
          NotificationStorage} = require("../adblockpluscore/lib/notification");
   const {getActiveNotification, shouldDisplay,
          notificationClicked} = require("../lib/notificationHelper");
+  const {HitLogger} = require("../lib/hitLogger");
 
   const {
     Filter, ActiveFilter, BlockingFilter, RegExpFilter
   } = require("../adblockpluscore/lib/filterClasses");
   const {Synchronizer} = require("../adblockpluscore/lib/synchronizer");
 
-  const info = require("../buildtools/info");

[kzar, 2018/05/17 13:53:27]

It turns out using a relative path for the info module is a bad idea, it caused
problems for the AdBlock guys (see #6675). Please could you leave this one as
`const info = require("info");`?

+  const info = require("info");
   const {
     Subscription,
     DownloadableSubscription,
-    SpecialSubscription
+    SpecialSubscription,
+    RegularSubscription
   } = require("../adblockpluscore/lib/subscriptionClasses");
 
   const {showOptions} = require("../lib/options");
 
   port.on("types.get", (message, sender) =>
   {
-    let filterTypes = Array.from(require("requestBlocker").filterTypes);
+    const filterTypes = Array.from(require("requestBlocker").filterTypes);
     filterTypes.push(...filterTypes.splice(filterTypes.indexOf("OTHER"), 1));
     return filterTypes;
   });
 
   function convertObject(keys, obj)
   {
-    let result = {};
-    for (let key of keys)
+    const result = {};
+    for (const key of keys)
     {
       if (key in obj)
         result[key] = obj[key];
     }
     return result;
   }
 
   function convertSubscription(subscription)
   {
-    let obj = convertObject(["disabled", "downloadStatus", "homepage",
-                             "version", "lastDownload", "lastSuccess",
-                             "softExpiration", "expires", "title",
-                             "url"], subscription);
+    const obj = convertObject(["disabled", "downloadStatus", "homepage",
+                               "version", "lastDownload", "lastSuccess",
+                               "softExpiration", "expires", "title",
+                               "url"], subscription);
     if (subscription instanceof SpecialSubscription)
       obj.filters = subscription.filters.map(convertFilter);
     obj.isDownloading = Synchronizer.isExecuting(subscription.url);
     return obj;
   }
 
-  let convertFilter = convertObject.bind(null, ["text"]);
-
-  let uiPorts = new Map();
-  let listenedPreferences = Object.create(null);
-  let listenedFilterChanges = Object.create(null);
-  let messageTypes = new Map([
+  const convertFilter = convertObject.bind(null, ["text"]);
+
+  const uiPorts = new Map();
+  const listenedPreferences = Object.create(null);
+  const listenedFilterChanges = Object.create(null);
+  const messageTypes = new Map([
     ["app", "app.respond"],
     ["filter", "filters.respond"],
     ["pref", "prefs.respond"],
+    ["requests", "requests.respond"],
     ["subscription", "subscriptions.respond"]
   ]);
 
   function sendMessage(type, action, ...args)
   {
     if (uiPorts.size == 0)
       return;
 
-    let convertedArgs = [];
-    for (let arg of args)
+    const convertedArgs = [];
+    for (const arg of args)
     {
       if (arg instanceof Subscription)
         convertedArgs.push(convertSubscription(arg));
       else if (arg instanceof Filter)
         convertedArgs.push(convertFilter(arg));
       else
         convertedArgs.push(arg);
     }
 
-    for (let [uiPort, filters] of uiPorts)
-    {
-      let actions = filters.get(type);
+    for (const [uiPort, filters] of uiPorts)
+    {
+      const actions = filters.get(type);
       if (actions && actions.indexOf(action) != -1)
       {
         uiPort.postMessage({
           type: messageTypes.get(type),
           action,
           args: convertedArgs
         });
       }
     }
   }
 
+  function includeActiveRemoteSubscriptions(s)
+  {
+    if (s.disabled || !(s instanceof RegularSubscription))
+      return false;
+    if (s instanceof DownloadableSubscription &&
+        !/^(http|https|ftp):/i.test(s.url))
+      return false;
+    return true;
+  }
+
+  function addRequestListeners(dataCollectionTabId, issueReporterTabId)
+  {
+    const logRequest = (request, filter) =>
+    {
+      let subscriptions = [];
+      if (filter)
+      {
+        subscriptions = filter.subscriptions.
+                        filter(includeActiveRemoteSubscriptions).
+                        map(s => s.url);
+        filter = convertFilter(filter);
+      }
+      request = convertObject(["url", "type", "docDomain", "thirdParty"],
+                              request);
+      sendMessage("requests", "hits", request, filter, subscriptions);
+    };
+    const removeTabListeners = (tabId) =>
+    {
+      if (tabId == dataCollectionTabId || tabId == issueReporterTabId)
+      {
+        HitLogger.removeListener(dataCollectionTabId, logRequest);
+        browser.tabs.onRemoved.removeListener(removeTabListeners);
+      }
+    };
+    HitLogger.addListener(dataCollectionTabId, logRequest);
+    browser.tabs.onRemoved.addListener(removeTabListeners);
+  }
+
   function addFilterListeners(type, actions)
   {
-    for (let action of actions)
+    for (const action of actions)
     {
       let name;
       if (type == "filter" && action == "loaded")
         name = "load";
       else
         name = type + "." + action;
 
       if (!(name in listenedFilterChanges))
       {
         listenedFilterChanges[name] = null;
@@ skipping 16 matching lines @@
     FilterStorage.addSubscription(subscription);
     if (subscription instanceof DownloadableSubscription &&
         !subscription.lastDownload)
       Synchronizer.execute(subscription);
   }
 
   port.on("app.get", (message, sender) =>
   {
     if (message.what == "issues")
     {
-      let subscriptionInit = require("../lib/subscriptionInit");
+      const subscriptionInit = require("subscriptionInit");
       return {
         dataCorrupted: subscriptionInit.isDataCorrupted(),
         filterlistsReinitialized: subscriptionInit.isReinitialized()
       };
     }
 
     if (message.what == "doclink")
     {
       let {application} = info;
       if (info.platform == "chromium" && application != "opera")
         application = "chrome";
       else if (info.platform == "gecko")
         application = "firefox";
 
       return Utils.getDocLink(message.link.replace("{browser}", application));
     }
 
     if (message.what == "localeInfo")
     {
       let bidiDir;
       if ("chromeRegistry" in Utils)
       {
-        let isRtl = Utils.chromeRegistry.isLocaleRTL("adblockplus");
+        const isRtl = Utils.chromeRegistry.isLocaleRTL("adblockplus");
         bidiDir = isRtl ? "rtl" : "ltr";
       }
       else
         bidiDir = Utils.readingDirection;
 
       return {locale: Utils.appLocale, bidiDir};
     }
 
     if (message.what == "features")
     {
@@ skipping 19 matching lines @@
         if (!message.action)
           return;
 
         sendMessage("app", message.action, ...message.args);
       });
     }
   });
 
   port.on("filters.add", (message, sender) =>
   {
-    let result = require("../lib/filterValidation").parseFilter(message.text);
-    let errors = [];
+    const result = require("filterValidation").parseFilter(message.text);
+    const errors = [];
     if (result.error)
       errors.push(result.error.toString());
     else if (result.filter)
       FilterStorage.addFilter(result.filter);
 
     return errors;
   });
 
   port.on("filters.blocked", (message, sender) =>
   {
-    let filter = defaultMatcher.matchesAny(message.url,
+    const filter = defaultMatcher.matchesAny(message.url,
       RegExpFilter.typeMap[message.requestType], message.docDomain,
       message.thirdParty);
 
     return filter instanceof BlockingFilter;
   });
 
   port.on("filters.get", (message, sender) =>
   {
-    let subscription = Subscription.fromURL(message.subscriptionUrl);
+    const subscription = Subscription.fromURL(message.subscriptionUrl);
     if (!subscription)
       return [];
 
     return subscription.filters.map(convertFilter);
   });
 
   port.on("filters.importRaw", (message, sender) =>
   {
-    let result = require("../lib/filterValidation").parseFilters(message.text);
-    let errors = [];
-    for (let error of result.errors)
+    const result = require("filterValidation").parseFilters(message.text);
+    const errors = [];
+    for (const error of result.errors)
     {
       if (error.type != "unexpected-filter-list-header")
         errors.push(error.toString());
     }
 
     if (errors.length > 0)
       return errors;
 
-    let seenFilter = Object.create(null);
-    for (let filter of result.filters)
+    const seenFilter = Object.create(null);
+    for (const filter of result.filters)
     {
       FilterStorage.addFilter(filter);
       seenFilter[filter.text] = null;
     }
 
     if (!message.removeExisting)
       return errors;
 
-    for (let subscription of FilterStorage.subscriptions)
+    for (const subscription of FilterStorage.subscriptions)
     {
       if (!(subscription instanceof SpecialSubscription))
         continue;
 
       for (let j = subscription.filters.length - 1; j >= 0; j--)
       {
-        let filter = subscription.filters[j];
+        const filter = subscription.filters[j];
         if (/^@@\|\|([^/:]+)\^\$document$/.test(filter.text))
           continue;
 
         if (!(filter.text in seenFilter))
           FilterStorage.removeFilter(filter);
       }
     }
 
     return errors;
   });
 
   port.on("filters.remove", (message, sender) =>
   {
-    let filter = Filter.fromText(message.text);
+    const filter = Filter.fromText(message.text);
     let subscription = null;
     if (message.subscriptionUrl)
       subscription = Subscription.fromURL(message.subscriptionUrl);
 
     if (!subscription)
       FilterStorage.removeFilter(filter);
     else
       FilterStorage.removeFilter(filter, subscription, message.index);
   });
 
@@ skipping 13 matching lines @@
   port.on("prefs.toggle", (message, sender) =>
   {
     if (message.key == "notifications_ignoredcategories")
       return NotificationStorage.toggleIgnoreCategory("*");
 
     return Prefs[message.key] = !Prefs[message.key];
   });
 
   port.on("notifications.get", (message, sender) =>
   {
-    let notification = getActiveNotification();
+    const notification = getActiveNotification();
 
     if (!notification ||
         "displayMethod" in message &&
         !shouldDisplay(message.displayMethod, notification.type))
       return;
 
-    let texts = NotificationStorage.getLocalizedTexts(notification,
+    const texts = NotificationStorage.getLocalizedTexts(notification,
                                                       message.locale);
     return Object.assign({texts}, notification);
   });
 
   port.on("notifications.clicked", (message, sender) =>
   {
     notificationClicked();
   });
 
   port.on("subscriptions.add", (message, sender) =>
   {
-    let subscription = Subscription.fromURL(message.url);
+    const subscription = Subscription.fromURL(message.url);
     if (message.confirm)
     {
       if ("title" in message)
         subscription.title = message.title;
       if ("homepage" in message)
         subscription.homepage = message.homepage;
 
       showOptions(() =>
       {
         sendMessage("app", "addSubscription", subscription);
       });
     }
     else
     {
       addSubscription(subscription, message);
     }
   });
 
   port.on("subscriptions.get", (message, sender) =>
   {
-    let subscriptions = FilterStorage.subscriptions.filter((s) =>
+    const subscriptions = FilterStorage.subscriptions.filter((s) =>
     {
       if (message.ignoreDisabled && s.disabled)
         return false;
       if (s instanceof DownloadableSubscription && message.downloadable)
         return true;
       if (s instanceof SpecialSubscription && message.special)
         return true;
       return false;
     });
 
     return subscriptions.map((s) =>
     {
-      let result = convertSubscription(s);
+      const result = convertSubscription(s);
       if (message.disabledFilters)
       {
         result.disabledFilters = s.filters
                       .filter((f) => f instanceof ActiveFilter && f.disabled)
                       .map((f) => f.text);
       }
       return result;
     });
   });
 
   port.on("subscriptions.remove", (message, sender) =>
   {
-    let subscription = Subscription.fromURL(message.url);
-    if (subscription.url in FilterStorage.knownSubscriptions)
+    const subscription = Subscription.fromURL(message.url);
+    if (FilterStorage.knownSubscriptions.has(subscription.url))
       FilterStorage.removeSubscription(subscription);
   });
 
   port.on("subscriptions.toggle", (message, sender) =>
   {
-    let subscription = Subscription.fromURL(message.url);
-    if (subscription.url in FilterStorage.knownSubscriptions)
+    const subscription = Subscription.fromURL(message.url);
+    if (FilterStorage.knownSubscriptions.has(subscription.url))
     {
       if (subscription.disabled || message.keepInstalled)
         subscription.disabled = !subscription.disabled;
       else
         FilterStorage.removeSubscription(subscription);
     }
     else
     {
       addSubscription(subscription, message);
     }
   });
 
   port.on("subscriptions.update", (message, sender) =>
   {
     let {subscriptions} = FilterStorage;
     if (message.url)
       subscriptions = [Subscription.fromURL(message.url)];
 
-    for (let subscription of subscriptions)
+    for (const subscription of subscriptions)
     {
       if (subscription instanceof DownloadableSubscription)
         Synchronizer.execute(subscription, true);
     }
   });
 
-  function listen(type, filters, newFilter)
+  function listen(type, filters, newFilter, message, senderTabId)
   {
     switch (type)
     {
       case "app":
         filters.set("app", newFilter);
         break;
       case "filters":
         filters.set("filter", newFilter);
         addFilterListeners("filter", newFilter);
         break;
       case "prefs":
         filters.set("pref", newFilter);
-        for (let preference of newFilter)
+        for (const preference of newFilter)
         {
           if (!(preference in listenedPreferences))
           {
             listenedPreferences[preference] = null;
             Prefs.on(preference, () =>
             {
               sendMessage("pref", preference, Prefs[preference]);
             });
           }
         }
         break;
       case "subscriptions":
         filters.set("subscription", newFilter);
         addFilterListeners("subscription", newFilter);
         break;
+      case "requests":
+        filters.set("requests", newFilter);
+        addRequestListeners(message.tabId, senderTabId);
+        break;
     }
   }
 
   function onConnect(uiPort)
   {
     if (uiPort.name != "ui")
       return;
 
-    let filters = new Map();
+    const filters = new Map();
     uiPorts.set(uiPort, filters);
 
     uiPort.onDisconnect.addListener(() =>
     {
       uiPorts.delete(uiPort);
     });
 
     uiPort.onMessage.addListener((message) =>
     {
-      let [type, action] = message.type.split(".", 2);
+      const [type, action] = message.type.split(".", 2);
 
       // For now we're only using long-lived connections for handling
       // "*.listen" messages to tackle #6440
       if (action == "listen")
       {
-        listen(type, filters, message.filter);
+        listen(type, filters, message.filter, message, uiPort.sender.tab.id);
       }
     });
   }
 
   browser.runtime.onConnect.addListener(onConnect);
 })(this);