Issue 6440 - Use long-lived connections to listen to extension events

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 58 matching lines @@
                              "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 changeListeners = new ext.PageMap();
+  let uiPorts = new Map();
   let listenedPreferences = Object.create(null);
   let listenedFilterChanges = Object.create(null);
   let messageTypes = new Map([
     ["app", "app.respond"],
     ["filter", "filters.respond"],
     ["pref", "prefs.respond"],
     ["subscription", "subscriptions.respond"]
   ]);
 
   function sendMessage(type, action, ...args)
   {
-    let pages = changeListeners.keys();
-    if (pages.length == 0)
+    if (uiPorts.size == 0)
       return;
 
     let convertedArgs = [];
     for (let 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 page of pages)
+    for (let [uiPort, filters] of uiPorts)
     {
-      let filters = changeListeners.get(page);
-      let actions = filters[type];
+      let actions = filters.get(type);
       if (actions && actions.indexOf(action) != -1)
       {
-        page.sendMessage({
+        uiPort.postMessage({
           type: messageTypes.get(type),
           action,
           args: convertedArgs
         });
       }
     }
   }
 
   function addFilterListeners(type, actions)
   {
     for (let action of actions)
     {
       let name;
       if (type == "filter" && action == "loaded")
         name = "load";
       else
         name = type + "." + action;
 
       if (!(name in listenedFilterChanges))
       {
         listenedFilterChanges[name] = null;
-        FilterNotifier.on(name, (...args) =>
+        FilterNotifier.on(name, (item) =>
         {
-          sendMessage(type, action, ...args);
+          sendMessage(type, action, item);
         });
       }
     }
   }
 
-  function getListenerFilters(page)
-  {
-    let listenerFilters = changeListeners.get(page);
-    if (!listenerFilters)
-    {
-      listenerFilters = Object.create(null);
-      changeListeners.set(page, listenerFilters);
-    }
-    return listenerFilters;
-  }
-
   function addSubscription(subscription, properties)
   {
     subscription.disabled = false;
     if ("title" in properties)
       subscription.title = properties.title;
     if ("homepage" in properties)
       subscription.homepage = properties.homepage;
 
     FilterStorage.addSubscription(subscription);
     if (subscription instanceof DownloadableSubscription &&
@@ skipping 43 matching lines @@
                        parseInt(info.applicationVersion, 10) >= 54
       };
     }
 
     if (message.what == "senderId")
       return sender.page.id;
 
     return info[message.what];
   });
 
-  port.on("app.listen", (message, sender) =>
-  {
-    getListenerFilters(sender.page).app = message.filter;
-  });
-
   port.on("app.open", (message, sender) =>
   {
     if (message.what == "options")
     {
       showOptions(() =>
       {
         if (!message.action)
           return;
 
         sendMessage("app", message.action, ...message.args);
@@ skipping 66 matching lines @@
           continue;
 
         if (!(filter.text in seenFilter))
           FilterStorage.removeFilter(filter);
       }
     }
 
     return errors;
   });
 
-  port.on("filters.listen", (message, sender) =>
-  {
-    getListenerFilters(sender.page).filter = message.filter;
-    addFilterListeners("filter", message.filter);
-  });
-
   port.on("filters.remove", (message, sender) =>
   {
     let 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);
   });
 
   port.on("prefs.get", (message, sender) =>
   {
     return Prefs[message.key];
   });
 
-  port.on("prefs.listen", (message, sender) =>
-  {
-    getListenerFilters(sender.page).pref = message.filter;
-    for (let preference of message.filter)
-    {
-      if (!(preference in listenedPreferences))
-      {
-        listenedPreferences[preference] = null;
-        Prefs.on(preference, () =>
-        {
-          sendMessage("pref", preference, Prefs[preference]);
-        });
-      }
-    }
-  });
-
   port.on("prefs.set", (message, sender) =>
   {
     if (message.key == "notifications_ignoredcategories")
       return NotificationStorage.toggleIgnoreCategory("*", !!message.value);
 
     return Prefs[message.key] = message.value;
   });
 
   port.on("prefs.toggle", (message, sender) =>
   {
@@ skipping 57 matching lines @@
       if (message.disabledFilters)
       {
         result.disabledFilters = s.filters
                       .filter((f) => f instanceof ActiveFilter && f.disabled)
                       .map((f) => f.text);
       }
       return result;
     });
   });
 
-  port.on("subscriptions.listen", (message, sender) =>
-  {
-    getListenerFilters(sender.page).subscription = message.filter;
-    addFilterListeners("subscription", message.filter);
-  });
-
   port.on("subscriptions.remove", (message, sender) =>
   {
     let subscription = Subscription.fromURL(message.url);
     if (subscription.url in FilterStorage.knownSubscriptions)
       FilterStorage.removeSubscription(subscription);
   });
 
   port.on("subscriptions.toggle", (message, sender) =>
   {
     let subscription = Subscription.fromURL(message.url);
@@ skipping 15 matching lines @@
     let {subscriptions} = FilterStorage;
     if (message.url)
       subscriptions = [Subscription.fromURL(message.url)];
 
     for (let subscription of subscriptions)
     {
       if (subscription instanceof DownloadableSubscription)
         Synchronizer.execute(subscription, true);
     }
   });
+
+  function listen(type, filters, newFilter)
+  {
+    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)
+        {
+          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;
+    }
+  }
+
+  function onConnect(uiPort)
+  {
+    if (uiPort.name != "ui")
+      return;
+
+    let filters = new Map();
+    uiPorts.set(uiPort, filters);
+
+    uiPort.onDisconnect.addListener(() =>
+    {
+      uiPorts.delete(uiPort);
+    });
+
+    uiPort.onMessage.addListener((message) =>
+    {
+      let [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);
+      }
+    });
+  }
+
+  browser.runtime.onConnect.addListener(onConnect);
 })(this);