Issue 6855 - Release all references to Subscription object once removed

lib/filterStorage.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 130 matching lines @@
   removeSubscription(subscription)
   {
     for (let i = 0; i < FilterStorage.subscriptions.length; i++)
     {
       if (FilterStorage.subscriptions[i].url == subscription.url)
       {
         removeSubscriptionFilters(subscription);
 
         FilterStorage.subscriptions.splice(i--, 1);
         FilterStorage.knownSubscriptions.delete(subscription.url);
+
+        // This should be the last remaining reference to the Subscription
+        // object.
+        Subscription.knownSubscriptions.delete(subscription.url);
+
         FilterNotifier.triggerListeners("subscription.removed", subscription);
-
-        subscription.free();

[Manish Jethani, 2018/08/11 15:28:17]

At this point all the other references to this object have been released, except
the one in Subscription.knownSubscriptions.

         return;
       }
     }
   },
 
   /**
    * Moves a subscription in the list to a new position.
    * @param {Subscription} subscription filter subscription to be moved
    * @param {Subscription} [insertBefore] filter subscription to insert before
    *        (if omitted the subscription will be put at the end of the list)
@@ skipping 41 matching lines @@
    * @param {Filter} filter
    * @param {SpecialSubscription} [subscription]
    *   particular group that the filter should be added to
    * @param {number} [position]
    *   position within the subscription at which the filter should be added
    */
   addFilter(filter, subscription, position)
   {
     if (!subscription)
     {
-      if (filter.subscriptions.some(s => s instanceof SpecialSubscription &&
-                                         !s.disabled))
-      {
-        return;   // No need to add
+      for (let currentSubscription of filter.subscriptions)
+      {
+        if (currentSubscription instanceof SpecialSubscription &&
+            !currentSubscription.disabled)
+        {
+          return;   // No need to add
+        }
       }
       subscription = FilterStorage.getGroupForFilter(filter);
     }
     if (!subscription)
     {
       // No group for this filter exists, create one
       subscription = SpecialSubscription.createForFilter(filter);
       this.addSubscription(subscription);
       return;
     }
 
     if (typeof position == "undefined")
       position = subscription.filters.length;
 
-    if (filter.subscriptions.indexOf(subscription) < 0)
-      filter.subscriptions.push(subscription);
+    filter.subscriptions.add(subscription);
     subscription.filters.splice(position, 0, filter);
     FilterNotifier.triggerListeners("filter.added", filter, subscription,
                                     position);
   },
 
   /**
    * Removes a user-defined filter from the list
    * @param {Filter} filter
    * @param {SpecialSubscription} [subscription] a particular filter group that
    *      the filter should be removed from (if ommited will be removed from all
    *      subscriptions)
    * @param {number} [position]  position inside the filter group at which the
    *      filter should be removed (if ommited all instances will be removed)
    */
   removeFilter(filter, subscription, position)
   {
     let subscriptions = (
-      subscription ? [subscription] : filter.subscriptions.slice()
+      subscription ? [subscription] : filter.subscriptions
     );
-    for (let i = 0; i < subscriptions.length; i++)
-    {
-      let currentSubscription = subscriptions[i];
+    for (let currentSubscription of subscriptions)
+    {
       if (currentSubscription instanceof SpecialSubscription)
       {
         let positions = [];
         if (typeof position == "undefined")
         {
           let index = -1;
           do
           {
             index = currentSubscription.filters.indexOf(filter, index + 1);
             if (index >= 0)
               positions.push(index);
           } while (index >= 0);
         }
         else
           positions.push(position);
 
         for (let j = positions.length - 1; j >= 0; j--)
         {
           let currentPosition = positions[j];
           if (currentSubscription.filters[currentPosition] == filter)
           {
             currentSubscription.filters.splice(currentPosition, 1);
             if (currentSubscription.filters.indexOf(filter) < 0)
-            {
-              let index = filter.subscriptions.indexOf(currentSubscription);
-              if (index >= 0)
-                filter.subscriptions.splice(index, 1);
-            }
+              filter.subscriptions.delete(currentSubscription);
             FilterNotifier.triggerListeners(
               "filter.removed", filter, currentSubscription, currentPosition
             );
           }
         }
       }
     }
   },
 
   /**
@@ skipping 362 matching lines @@
  * Joins subscription's filters to the subscription without any notifications.
  * @param {Subscription} subscription
  *   filter subscription that should be connected to its filters
  */
 function addSubscriptionFilters(subscription)
 {
   if (!FilterStorage.knownSubscriptions.has(subscription.url))
     return;
 
   for (let filter of subscription.filters)
-    filter.subscriptions.push(subscription);
+    filter.subscriptions.add(subscription);
 }
 
 /**
  * Removes subscription's filters from the subscription without any
  * notifications.
  * @param {Subscription} subscription filter subscription to be removed
  */
 function removeSubscriptionFilters(subscription)
 {
   if (!FilterStorage.knownSubscriptions.has(subscription.url))
     return;
 
   for (let filter of subscription.filters)
-  {
-    let i = filter.subscriptions.indexOf(subscription);
-    if (i >= 0)
-      filter.subscriptions.splice(i, 1);
-  }
+    filter.subscriptions.delete(subscription);
 }
 
 /**
  * Listener returned by FilterStorage.importData(), parses filter data.
  * @constructor
  */
 function INIParser()
 {
   this.fileProperties = this.curObj = {};
   this.subscriptions = [];
@@ skipping 42 matching lines @@
             case "subscription filters":
               if (this.subscriptions.length)
               {
                 let subscription = this.subscriptions[
                   this.subscriptions.length - 1
                 ];
                 for (let text of this.curObj)
                 {
                   let filter = Filter.fromText(text);
                   subscription.filters.push(filter);
-                  filter.subscriptions.push(subscription);
+                  filter.subscriptions.add(subscription);
                 }
               }
               break;
           }
         }
 
         if (val === null)
           return;
 
         this.curSection = match[1].toLowerCase();
@@ skipping 16 matching lines @@
       else if (this.wantObj === false && val)
         this.curObj.push(val.replace(/\\\[/g, "["));
     }
     finally
     {
       Filter.knownFilters = origKnownFilters;
       Subscription.knownSubscriptions = origKnownSubscriptions;
     }
   }
 };