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

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 177 matching lines @@
    */
   addSubscription(subscription)
   {
     if (this.knownSubscriptions.has(subscription.url))
       return;
 
     this.knownSubscriptions.set(subscription.url, subscription);
     connectSubscriptionFilters(subscription);
 
     filterNotifier.emit("subscription.added", subscription);
+
+    subscription.clearCaches();
   }
 
   /**
    * Removes a subscription from the storage.
    * @param {Subscription} subscription The subscription to be removed.
    */
   removeSubscription(subscription)
   {
     if (!this.knownSubscriptions.has(subscription.url))
       return;
@@ skipping 19 matching lines @@
     let oldFilters = [...subscription.filters()];
     disconnectSubscriptionFilters(subscription, oldFilters);
     subscription.clearFilters();
 
     for (let filter of filters)
       subscription.addFilter(filter);
 
     connectSubscriptionFilters(subscription, filters);
 
     filterNotifier.emit("subscription.updated", subscription, oldFilters);
+
+    subscription.clearCaches();
   }
 
   /**
    * Adds a user-defined filter to the storage.
    * @param {Filter} filter
    * @param {?SpecialSubscription} [subscription] The subscription that the
    *   filter should be added to.
    * @param {number} [position] The position within the subscription at which
    *   the filter should be added. If not specified, the filter is added at the
    *   end of the subscription.
    */
   addFilter(filter, subscription, position)
   {
     if (!subscription)
     {
-      for (let currentSubscription of filter.subscriptions())
+      for (let currentSubscription of this.subscriptionsForFilter(filter))
       {
         if (currentSubscription instanceof SpecialSubscription &&
             !currentSubscription.disabled)
         {
           return;   // No need to add
         }
       }
       subscription = this.getGroupForFilter(filter);
     }
     if (!subscription)
@@ skipping 18 matching lines @@
    * @param {?SpecialSubscription} [subscription] The subscription that the
    *   filter should be removed from. If not specified, the filter will be
    *   removed from all subscriptions.
    * @param {number} [position] The position within the subscription at which
    *   the filter should be removed. If not specified, all instances of the
    *   filter will be removed.
    */
   removeFilter(filter, subscription, position)
   {
     let subscriptions = (
-      subscription ? [subscription] : filter.subscriptions()
+      subscription ? [subscription] : this.subscriptionsForFilter(filter)
     );
     for (let currentSubscription of subscriptions)
     {
       if (currentSubscription instanceof SpecialSubscription)
       {
         let positions = [];
         if (typeof position == "undefined")
         {
           let index = -1;
           do
@@ skipping 105 matching lines @@
         let knownSubscriptions = new Map();
         for (let subscription of parser.subscriptions)
           knownSubscriptions.set(subscription.url, subscription);
 
         this.fileProperties = parser.fileProperties;
         this.knownSubscriptions = knownSubscriptions;
         Filter.knownFilters = parser.knownFilters;
         Subscription.knownSubscriptions = parser.knownSubscriptions;
 
         if (!silent)
+        {
           filterNotifier.emit("load");
+
+          // Clear any in-memory caches that may have been created during
+          // initialization.
+          clearSubscriptionCaches();
+        }
       }
     };
   }
 
   /**
    * Loads all subscriptions from disk.
    * @returns {Promise} A promise resolved or rejected when loading is complete.
    */
   loadFromDisk()
   {
@@ skipping 28 matching lines @@
         }
       });
     }).catch(error =>
     {
       Cu.reportError(error);
       return tryBackup(1);
     }).then(() =>
     {
       this.initialized = true;
       filterNotifier.emit("load");
+      clearSubscriptionCaches();
     });
   }
 
   /**
    * Constructs the file name for a <code>patterns.ini</code> backup.
    * @param {number} backupIndex Number of the backup file (1 being the most
    *   recent).
    * @returns {string} Backup file name.
    */
   getBackupName(backupIndex)
@@ skipping 243 matching lines @@
  *   subscription is disconnected from its own filters.
  */
 function disconnectSubscriptionFilters(subscription, filters)
 {
   if (!filterStorage.knownSubscriptions.has(subscription.url))
     return;
 
   for (let filter of filters || subscription.filters())
     filter.removeSubscription(subscription);
 }
+
+/**
+ * Clears any in-memory caches held by subscriptions in the storage.
+ */
+function clearSubscriptionCaches()
+{
+  for (let subscription of filterStorage.subscriptions())
+    subscription.clearCaches();
+}