Issue 7096 - Make it possible to lazy initialize a filter's subscriptions

lib/filterListener.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 122 matching lines @@
 /**
  * Notifies Matcher instances or ElemHide object about a new filter
  * if necessary.
  * @param {Filter} filter filter that has been added
  */
 function addFilter(filter)
 {
   if (!(filter instanceof ActiveFilter) || filter.disabled)
     return;
 
-  if (!filter.subscriptionsAdded)

[Manish Jethani, 2018/11/03 21:31:25]

The subscriptions will already be added when the subscriptions are initially
loaded, but when we move to ephemeral filter objects, newly created filter
objects won't have their subscriptions added by default.

This code runs when the subscriptions are initially loaded and then again when a
new version of a subscription is downloaded. For the latter case, the
performance will be worse than it currently is, but this happens once a day per
subscription on average, it should not be a problem. In comparison, having
ephemeral filter objects that don't have their subscriptions already added would
allow us to save several megabytes of memory (the savings come from the objects
not being added to the `Filter.knownFilters` map as well as not being held on to
in other places). It's a good tradeoff.

-    filterStorage.addSubscriptionsToFilter(filter);
-
   let hasEnabled = false;
   let allowSnippets = false;
-  for (let subscription of filter.subscriptions())
+  for (let subscription of filterStorage.subscriptionsForFilter(filter))
   {
     if (!subscription.disabled)
     {
       hasEnabled = true;
 
       // Allow snippets to be executed only by the circumvention lists or the
       // user's own filters.
       if (subscription.type == "circumvention" ||
           subscription.url == "https://easylist-downloads.adblockplus.org/abp-filters-anti-cv.txt" ||
           subscription instanceof SpecialSubscription)
@@ skipping 26 matching lines @@
  * if necessary.
  * @param {Filter} filter filter that has been removed
  */
 function removeFilter(filter)
 {
   if (!(filter instanceof ActiveFilter))
     return;
 
   if (!filter.disabled)
   {
-    if (!filter.subscriptionsAdded)
-      filterStorage.addSubscriptionsToFilter(filter);
-
     let hasEnabled = false;
-    for (let subscription of filter.subscriptions())
+    for (let subscription of filterStorage.subscriptionsForFilter(filter))
     {
       if (!subscription.disabled)
       {
         hasEnabled = true;
         break;
       }
     }
     if (hasEnabled)
       return;
   }
 
   if (filter instanceof RegExpFilter)
     defaultMatcher.remove(filter);
   else if (filter instanceof ElemHideBase)
   {
     if (filter instanceof ElemHideFilter)
       ElemHide.remove(filter);
     else if (filter instanceof ElemHideEmulationFilter)
       ElemHideEmulation.remove(filter);
     else
       ElemHideExceptions.remove(filter);
   }
   else if (filter instanceof SnippetFilter)
     Snippets.remove(filter);
 }
 
 const primes = [101, 109, 131, 149, 163, 179, 193, 211, 229, 241];
 
-function addFilters(filters)
+function addSubscriptionFilters(subscription)
 {
   // We add filters using pseudo-random ordering. Reason is that ElemHide will
   // assign consecutive filter IDs that might be visible to the website. The
   // randomization makes sure that no conclusion can be made about the actual
   // filters applying there. We have ten prime numbers to use as iteration step,
   // any of those can be chosen as long as the array length isn't divisible by
   // it.
-  let len = filters.length;
+  let len = subscription.filterCount;
   if (!len)
     return;
 
   let current = (Math.random() * len) | 0;
   let step;
   do
   {
     step = primes[(Math.random() * primes.length) | 0];
   } while (len % step == 0);
 
   for (let i = 0; i < len; i++, current = (current + step) % len)
-    addFilter(filters[current]);
+    addFilter(subscription.filterAt(current));
 }
 
 function onSubscriptionAdded(subscription)
 {
   FilterListener.setDirty(1);
 
   if (!subscription.disabled)
-    addFilters(subscription.filters);
+    addSubscriptionFilters(subscription);
 }
 
 function onSubscriptionRemoved(subscription)
 {
   FilterListener.setDirty(1);
 
   if (!subscription.disabled)
-    subscription.filters.forEach(removeFilter);
+  {
+    for (let filter of subscription.filters())
+      removeFilter(filter);
+  }
 }
 
 function onSubscriptionDisabled(subscription, newValue)
 {
   FilterListener.setDirty(1);
 
   if (filterStorage.knownSubscriptions.has(subscription.url))
   {
     if (newValue == false)
-      addFilters(subscription.filters);
+    {
+      addSubscriptionFilters(subscription);
+    }
     else
-      subscription.filters.forEach(removeFilter);
+    {
+      for (let filter of subscription.filters())
+        removeFilter(filter);
+    }
   }
 }
 
 function onSubscriptionUpdated(subscription, oldFilters)
 {
   FilterListener.setDirty(1);
 
   if (!subscription.disabled &&
       filterStorage.knownSubscriptions.has(subscription.url))
   {
-    oldFilters.forEach(removeFilter);
-    addFilters(subscription.filters);
+    for (let filter of oldFilters)
+      removeFilter(filter);
+
+    addSubscriptionFilters(subscription);
   }
 }
 
 function onFilterHitCount(filter, newValue)
 {
   if (newValue == 0)
     FilterListener.setDirty(0);
   else
     FilterListener.setDirty(0.002);
 }
@@ skipping 36 matching lines @@
 
 function onLoad()
 {
   isDirty = 0;
 
   defaultMatcher.clear();
   ElemHide.clear();
   ElemHideEmulation.clear();
   ElemHideExceptions.clear();
   Snippets.clear();
+
   for (let subscription of filterStorage.subscriptions())
   {
     if (!subscription.disabled)
-      addFilters(subscription.filters);
+      addSubscriptionFilters(subscription);
   }
 }
 
 function onSave()
 {
   isDirty = 0;
 }