Index: lib/filterListener.js
===================================================================
--- a/lib/filterListener.js
+++ b/lib/filterListener.js
@@ -20,17 +20,17 @@
 /**
  * @fileOverview Component synchronizing filter storage with Matcher
  *               instances and ElemHide.
  */
 
 const {Services} = Cu.import("resource://gre/modules/Services.jsm", {});
 const {XPCOMUtils} = Cu.import("resource://gre/modules/XPCOMUtils.jsm", {});
 
-const {FilterStorage} = require("./filterStorage");
+const {filterStorage} = require("./filterStorage");
 const {filterNotifier} = require("./filterNotifier");
 const {ElemHide} = require("./elemHide");
 const {ElemHideEmulation} = require("./elemHideEmulation");
 const {ElemHideExceptions} = require("./elemHideExceptions");
 const {Snippets} = require("./snippets");
 const {defaultMatcher} = require("./matcher");
 const {ActiveFilter, RegExpFilter,
        ElemHideBase, ElemHideFilter, ElemHideEmulationFilter,
@@ -46,47 +46,47 @@
 
 /**
  * This object can be used to change properties of the filter change listeners.
  * @class
  */
 let FilterListener = {
   /**
    * Increases "dirty factor" of the filters and calls
-   * FilterStorage.saveToDisk() if it becomes 1 or more. Save is
+   * filterStorage.saveToDisk() if it becomes 1 or more. Save is
    * executed delayed to prevent multiple subsequent calls. If the
    * parameter is 0 it forces saving filters if any changes were
    * recorded after the previous save.
    * @param {number} factor
    */
   setDirty(factor)
   {
     if (factor == 0 && isDirty > 0)
       isDirty = 1;
     else
       isDirty += factor;
     if (isDirty >= 1)
     {
       isDirty = 0;
-      FilterStorage.saveToDisk();
+      filterStorage.saveToDisk();
     }
   }
 };
 
 /**
  * Observer listening to history purge actions.
  * @class
  */
 let HistoryPurgeObserver = {
   observe(subject, topic, data)
   {
     if (topic == "browser:purge-session-history" &&
         Prefs.clearStatsOnHistoryPurge)
     {
-      FilterStorage.resetHitCounts();
+      filterStorage.resetHitCounts();
       FilterListener.setDirty(0); // Force saving to disk
 
       Prefs.recentReports = [];
     }
   },
   QueryInterface: XPCOMUtils.generateQI(
     [Ci.nsISupportsWeakReference, Ci.nsIObserver]
   )
@@ -113,17 +113,17 @@
   filterNotifier.on("subscription.homepage", onGenericChange);
   filterNotifier.on("subscription.downloadStatus", onGenericChange);
   filterNotifier.on("subscription.lastCheck", onGenericChange);
   filterNotifier.on("subscription.errors", onGenericChange);
 
   filterNotifier.on("load", onLoad);
   filterNotifier.on("save", onSave);
 
-  FilterStorage.loadFromDisk();
+  filterStorage.loadFromDisk();
 
   Services.obs.addObserver(HistoryPurgeObserver,
                            "browser:purge-session-history", true);
   onShutdown.add(() =>
   {
     Services.obs.removeObserver(HistoryPurgeObserver,
                                 "browser:purge-session-history");
   });
@@ -257,31 +257,31 @@
   if (!subscription.disabled)
     subscription.filters.forEach(removeFilter);
 }
 
 function onSubscriptionDisabled(subscription, newValue)
 {
   FilterListener.setDirty(1);
 
-  if (FilterStorage.knownSubscriptions.has(subscription.url))
+  if (filterStorage.knownSubscriptions.has(subscription.url))
   {
     if (newValue == false)
       addFilters(subscription.filters);
     else
       subscription.filters.forEach(removeFilter);
   }
 }
 
 function onSubscriptionUpdated(subscription, oldFilters)
 {
   FilterListener.setDirty(1);
 
   if (!subscription.disabled &&
-      FilterStorage.knownSubscriptions.has(subscription.url))
+      filterStorage.knownSubscriptions.has(subscription.url))
   {
     oldFilters.forEach(removeFilter);
     addFilters(subscription.filters);
   }
 }
 
 function onFilterHitCount(filter, newValue)
 {
@@ -331,17 +331,17 @@
 {
   isDirty = 0;
 
   defaultMatcher.clear();
   ElemHide.clear();
   ElemHideEmulation.clear();
   ElemHideExceptions.clear();
   Snippets.clear();
-  for (let subscription of FilterStorage.subscriptions())
+  for (let subscription of filterStorage.subscriptions())
   {
     if (!subscription.disabled)
       addFilters(subscription.filters);
   }
 }
 
 function onSave()
 {
Index: lib/filterStorage.js
===================================================================
--- a/lib/filterStorage.js
+++ b/lib/filterStorage.js
@@ -13,224 +13,250 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 "use strict";
 
 /**
- * @fileOverview FilterStorage class responsible for managing user's
- *               subscriptions and filters.
+ * @fileOverview <code>filterStorage</code> object responsible for managing the
+ * user's subscriptions and filters.
  */
 
 const {IO} = require("io");
 const {Prefs} = require("prefs");
 const {Filter, ActiveFilter} = require("./filterClasses");
 const {Subscription, SpecialSubscription,
        ExternalSubscription} = require("./subscriptionClasses");
 const {filterNotifier} = require("./filterNotifier");
 const {INIParser} = require("./iniParser");
 
 /**
  * Version number of the filter storage file format.
  * @type {number}
  */
-let formatVersion = 5;
+const FORMAT_VERSION = 5;
 
 /**
- * This class reads user's filters from disk, manages them in memory
- * and writes them back.
- * @class
+ * {@link filterStorage} implementation.
  */
-let FilterStorage = exports.FilterStorage =
+class FilterStorage
 {
   /**
-   * Will be set to true after the initial loadFromDisk() call completes.
-   * @type {boolean}
+   * @hideconstructor
    */
-  initialized: false,
+  constructor()
+  {
+    /**
+     * Will be set to true after the initial {@link FilterStorage#loadFromDisk}
+     * call completes.
+     * @type {boolean}
+     */
+    this.initialized = false;
+
+    /**
+     * Will be set to <code>true</code> if no <code>patterns.ini</code> file
+     * exists.
+     * @type {boolean}
+     */
+    this.firstRun = false;
+
+    /**
+     * Map of properties listed in the filter storage file before the sections
+     * start. Right now this should be only the format version.
+     * @type {object}
+     */
+    this.fileProperties = Object.create(null);
+
+    /**
+     * Map of subscriptions already on the list, by their URL/identifier.
+     * @type {Map.<string,Subscription>}
+     */
+    this.knownSubscriptions = new Map();
+
+    /**
+     * Will be set to true if {@link FilterStorage#saveToDisk} is running
+     * (reentrance protection).
+     * @type {boolean}
+     * @private
+     */
+    this._saving = false;
+
+    /**
+     * Will be set to true if a {@link FilterStorage#saveToDisk} call arrives
+     * while {@link FilterStorage#saveToDisk} is already running (delayed
+     * execution).
+     * @type {boolean}
+     * @private
+     */
+    this._needsSave = false;
+  }
 
   /**
-   * Version number of the patterns.ini format used.
+   * The version number of the <code>patterns.ini</code> format used.
    * @type {number}
    */
   get formatVersion()
   {
-    return formatVersion;
-  },
+    return FORMAT_VERSION;
+  }
 
   /**
-   * File containing the filter list
+   * The file containing the subscriptions.
    * @type {string}
    */
   get sourceFile()
   {
     return "patterns.ini";
-  },
+  }
 
   /**
-   * Will be set to true if no patterns.ini file exists.
-   * @type {boolean}
-   */
-  firstRun: false,
-
-  /**
-   * Map of properties listed in the filter storage file before the sections
-   * start. Right now this should be only the format version.
-   */
-  fileProperties: Object.create(null),
-
-  /**
-   * Yields subscriptions containing all filters
+   * Yields all subscriptions in the storage.
    * @yields {Subscription}
    */
   *subscriptions()
   {
     yield* this.knownSubscriptions.values();
-  },
+  }
 
   /**
-   * Number of known subscriptions.
+   * The number of subscriptions in the storage.
    * @type {number}
    */
   get subscriptionCount()
   {
     return this.knownSubscriptions.size;
-  },
-
-  /**
-   * Map of subscriptions already on the list, by their URL/identifier
-   * @type {Map.<string,Subscription>}
-   */
-  knownSubscriptions: new Map(),
+  }
 
   /**
    * Finds the filter group that a filter should be added to by default. Will
-   * return null if this group doesn't exist yet.
+   * return <code>null</code> if this group doesn't exist yet.
    * @param {Filter} filter
-   * @return {?SpecialSubscription}
+   * @returns {?SpecialSubscription}
    */
   getGroupForFilter(filter)
   {
     let generalSubscription = null;
-    for (let subscription of FilterStorage.knownSubscriptions.values())
+    for (let subscription of this.knownSubscriptions.values())
     {
       if (subscription instanceof SpecialSubscription && !subscription.disabled)
       {
         // Always prefer specialized subscriptions
         if (subscription.isDefaultFor(filter))
           return subscription;
 
         // If this is a general subscription - store it as fallback
         if (!generalSubscription &&
             (!subscription.defaults || !subscription.defaults.length))
         {
           generalSubscription = subscription;
         }
       }
     }
     return generalSubscription;
-  },
+  }
 
   /**
-   * Adds a filter subscription to the list
-   * @param {Subscription} subscription filter subscription to be added
+   * Adds a subscription to the storage.
+   * @param {Subscription} subscription The subscription to be added.
    */
   addSubscription(subscription)
   {
-    if (FilterStorage.knownSubscriptions.has(subscription.url))
+    if (this.knownSubscriptions.has(subscription.url))
       return;
 
-    FilterStorage.knownSubscriptions.set(subscription.url, subscription);
-    addSubscriptionFilters(subscription);
+    this.knownSubscriptions.set(subscription.url, subscription);
+    connectSubscriptionFilters(subscription);
 
     filterNotifier.emit("subscription.added", subscription);
-  },
+  }
 
   /**
-   * Removes a filter subscription from the list
-   * @param {Subscription} subscription filter subscription to be removed
+   * Removes a subscription from the storage.
+   * @param {Subscription} subscription The subscription to be removed.
    */
   removeSubscription(subscription)
   {
-    if (!FilterStorage.knownSubscriptions.has(subscription.url))
+    if (!this.knownSubscriptions.has(subscription.url))
       return;
 
-    removeSubscriptionFilters(subscription);
+    disconnectSubscriptionFilters(subscription);
 
-    FilterStorage.knownSubscriptions.delete(subscription.url);
+    this.knownSubscriptions.delete(subscription.url);
 
     // This should be the last remaining reference to the Subscription
     // object.
     Subscription.knownSubscriptions.delete(subscription.url);
 
     filterNotifier.emit("subscription.removed", subscription);
-  },
+  }
 
   /**
-   * Replaces the list of filters in a subscription by a new list
-   * @param {Subscription} subscription filter subscription to be updated
-   * @param {Filter[]} filters new filter list
+   * Replaces the list of filters in a subscription with a new list.
+   * @param {Subscription} subscription The subscription to be updated.
+   * @param {Array.<Filter>} filters The new list of filters.
    */
   updateSubscriptionFilters(subscription, filters)
   {
-    removeSubscriptionFilters(subscription);
+    disconnectSubscriptionFilters(subscription);
     let oldFilters = subscription.filters;
     subscription.filters = filters;
-    addSubscriptionFilters(subscription);
+    connectSubscriptionFilters(subscription);
     filterNotifier.emit("subscription.updated", subscription, oldFilters);
-  },
+  }
 
   /**
-   * Adds a user-defined filter to the list
+   * Adds a user-defined filter to the storage.
    * @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
+   * @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())
       {
         if (currentSubscription instanceof SpecialSubscription &&
             !currentSubscription.disabled)
         {
           return;   // No need to add
         }
       }
-      subscription = FilterStorage.getGroupForFilter(filter);
+      subscription = this.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;
 
     filter.addSubscription(subscription);
     subscription.filters.splice(position, 0, filter);
     filterNotifier.emit("filter.added", filter, subscription, position);
-  },
+  }
 
   /**
-   * Removes a user-defined filter from the list
+   * Removes a user-defined filter from the storage.
    * @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)
+   * @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()
     );
     for (let currentSubscription of subscriptions)
     {
@@ -259,25 +285,25 @@
             if (currentSubscription.filters.indexOf(filter) < 0)
               filter.removeSubscription(currentSubscription);
             filterNotifier.emit("filter.removed", filter, currentSubscription,
                                 currentPosition);
           }
         }
       }
     }
-  },
+  }
 
   /**
-   * Moves a user-defined filter to a new position
+   * Moves a user-defined filter to a new position.
    * @param {Filter} filter
-   * @param {SpecialSubscription} subscription filter group where the filter is
-   *                                           located
-   * @param {number} oldPosition current position of the filter
-   * @param {number} newPosition new position of the filter
+   * @param {SpecialSubscription} subscription The subscription where the
+   *   filter is located.
+   * @param {number} oldPosition The current position of the filter.
+   * @param {number} newPosition The new position of the filter.
    */
   moveFilter(filter, subscription, oldPosition, newPosition)
   {
     if (!(subscription instanceof SpecialSubscription) ||
         subscription.filters[oldPosition] != filter)
     {
       return;
     }
@@ -286,61 +312,60 @@
                            subscription.filters.length - 1);
     if (oldPosition == newPosition)
       return;
 
     subscription.filters.splice(oldPosition, 1);
     subscription.filters.splice(newPosition, 0, filter);
     filterNotifier.emit("filter.moved", filter, subscription, oldPosition,
                         newPosition);
-  },
+  }
 
   /**
-   * Increases the hit count for a filter by one
+   * Increases the hit count for a filter by one.
    * @param {Filter} filter
    */
   increaseHitCount(filter)
   {
     if (!Prefs.savestats || !(filter instanceof ActiveFilter))
       return;
 
     filter.hitCount++;
     filter.lastHit = Date.now();
-  },
+  }
 
   /**
-   * Resets hit count for some filters
-   * @param {Filter[]} filters  filters to be reset, if null all filters will
-   *                            be reset
+   * Resets hit count for some filters.
+   * @param {?Array.<Filter>} [filters] The filters to be reset. If not
+   *   specified, all filters will be reset.
    */
   resetHitCounts(filters)
   {
     if (!filters)
       filters = Filter.knownFilters.values();
     for (let filter of filters)
     {
       filter.hitCount = 0;
       filter.lastHit = 0;
     }
-  },
+  }
 
   /**
    * @callback TextSink
    * @param {string?} line
    */
 
   /**
    * Allows importing previously serialized filter data.
-   * @param {boolean} silent
-   *    If true, no "load" notification will be sent out.
-   * @return {TextSink}
-   *    Function to be called for each line of data. Calling it with null as
-   *    parameter finalizes the import and replaces existing data. No changes
-   *    will be applied before finalization, so import can be "aborted" by
-   *    forgetting this callback.
+   * @param {boolean} silent If <code>true</code>, no "load" notification will
+   *   be sent out.
+   * @returns {TextSink} The function to be called for each line of data.
+   *   Calling it with <code>null</code> as the argument finalizes the import
+   *   and replaces existing data. No changes will be applied before
+   *   finalization, so import can be "aborted" by forgetting this callback.
    */
   importData(silent)
   {
     let parser = new INIParser();
     return line =>
     {
       parser.process(line);
       if (line === null)
@@ -353,21 +378,21 @@
         this.knownSubscriptions = knownSubscriptions;
         Filter.knownFilters = parser.knownFilters;
         Subscription.knownSubscriptions = parser.knownSubscriptions;
 
         if (!silent)
           filterNotifier.emit("load");
       }
     };
-  },
+  }
 
   /**
-   * Loads all subscriptions from the disk.
-   * @return {Promise} promise resolved or rejected when loading is complete
+   * Loads all subscriptions from disk.
+   * @returns {Promise} A promise resolved or rejected when loading is complete.
    */
   loadFromDisk()
   {
     let tryBackup = backupIndex =>
     {
       return this.restoreBackup(backupIndex, true).then(() =>
       {
         if (this.knownSubscriptions.size == 0)
@@ -400,68 +425,70 @@
     {
       Cu.reportError(error);
       return tryBackup(1);
     }).then(() =>
     {
       this.initialized = true;
       filterNotifier.emit("load");
     });
-  },
+  }
 
   /**
-   * Constructs the file name for a patterns.ini backup.
-   * @param {number} backupIndex
-   *    number of the backup file (1 being the most recent)
-   * @return {string} backup file name
+   * 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)
   {
     let [name, extension] = this.sourceFile.split(".", 2);
     return (name + "-backup" + backupIndex + "." + extension);
-  },
+  }
 
   /**
    * Restores an automatically created backup.
-   * @param {number} backupIndex
-   *    number of the backup to restore (1 being the most recent)
-   * @param {boolean} silent
-   *    If true, no "load" notification will be sent out.
-   * @return {Promise} promise resolved or rejected when restoring is complete
+   * @param {number} backupIndex Number of the backup to restore (1 being the
+   *   most recent).
+   * @param {boolean} silent If <code>true</code>, no "load" notification will
+   *   be sent out.
+   * @returns {Promise} A promise resolved or rejected when restoration is
+   *   complete.
    */
   restoreBackup(backupIndex, silent)
   {
     let backupFile = this.getBackupName(backupIndex);
     let parser = this.importData(silent);
     return IO.readFromFile(backupFile, parser).then(() =>
     {
       parser(null);
       return this.saveToDisk();
     });
-  },
+  }
 
   /**
    * Generator serializing filter data and yielding it line by line.
+   * @yields {string}
    */
   *exportData()
   {
     // Do not persist external subscriptions
     let subscriptions = [];
     for (let subscription of this.subscriptions())
     {
       if (!(subscription instanceof ExternalSubscription) &&
           !(subscription instanceof SpecialSubscription &&
             subscription.filters.length == 0))
       {
         subscriptions.push(subscription);
       }
     }
 
     yield "# Adblock Plus preferences";
-    yield "version=" + formatVersion;
+    yield "version=" + this.formatVersion;
 
     let saved = new Set();
     let buf = [];
 
     // Save subscriptions
     for (let subscription of subscriptions)
     {
       yield "";
@@ -487,34 +514,21 @@
           filter.serialize(buf);
           saved.add(filter.text);
           for (let line of buf)
             yield line;
           buf.splice(0);
         }
       }
     }
-  },
-
-  /**
-   * Will be set to true if saveToDisk() is running (reentrance protection).
-   * @type {boolean}
-   */
-  _saving: false,
+  }
 
   /**
-   * Will be set to true if a saveToDisk() call arrives while saveToDisk() is
-   * already running (delayed execution).
-   * @type {boolean}
-   */
-  _needsSave: false,
-
-  /**
-   * Saves all subscriptions back to disk
-   * @return {Promise} promise resolved or rejected when saving is complete
+   * Saves all subscriptions back to disk.
+   * @returns {Promise} A promise resolved or rejected when saving is complete.
    */
   saveToDisk()
   {
     if (this._saving)
     {
       this._needsSave = true;
       return;
     }
@@ -588,28 +602,28 @@
     {
       this._saving = false;
       if (this._needsSave)
       {
         this._needsSave = false;
         this.saveToDisk();
       }
     });
-  },
+  }
 
   /**
    * @typedef FileInfo
    * @type {object}
    * @property {number} index
    * @property {number} lastModified
    */
 
   /**
    * Returns a promise resolving in a list of existing backup files.
-   * @return {Promise.<FileInfo[]>}
+   * @returns {Promise.<Array.<FileInfo>>}
    */
   getBackupFiles()
   {
     let backups = [];
 
     let checkBackupFile = index =>
     {
       return IO.statFile(this.getBackupName(index)).then(statData =>
@@ -627,37 +641,45 @@
         // Something went wrong, return whatever data we got so far.
         Cu.reportError(error);
         return backups;
       });
     };
 
     return checkBackupFile(1);
   }
-};
+}
 
 /**
- * Joins subscription's filters to the subscription without any notifications.
- * @param {Subscription} subscription
- *   filter subscription that should be connected to its filters
+ * Reads the user's filters from disk, manages them in memory, and writes them
+ * back to disk.
  */
-function addSubscriptionFilters(subscription)
+let filterStorage = new FilterStorage();
+
+exports.filterStorage = filterStorage;
+
+/**
+ * Connects a subscription to its filters without any notifications.
+ * @param {Subscription} subscription The subscription that should be
+ *   connected to its filters.
+ */
+function connectSubscriptionFilters(subscription)
 {
-  if (!FilterStorage.knownSubscriptions.has(subscription.url))
+  if (!filterStorage.knownSubscriptions.has(subscription.url))
     return;
 
   for (let filter of subscription.filters)
     filter.addSubscription(subscription);
 }
 
 /**
- * Removes subscription's filters from the subscription without any
- * notifications.
- * @param {Subscription} subscription filter subscription to be removed
+ * Disconnects a subscription from its filters without any notifications.
+ * @param {Subscription} subscription The subscription that should be
+ *   disconnected from its filters.
  */
-function removeSubscriptionFilters(subscription)
+function disconnectSubscriptionFilters(subscription)
 {
-  if (!FilterStorage.knownSubscriptions.has(subscription.url))
+  if (!filterStorage.knownSubscriptions.has(subscription.url))
     return;
 
   for (let filter of subscription.filters)
     filter.removeSubscription(subscription);
 }
Index: lib/synchronizer.js
===================================================================
--- a/lib/synchronizer.js
+++ b/lib/synchronizer.js
@@ -20,17 +20,17 @@
 /**
  * @fileOverview Manages synchronization of filter subscriptions.
  */
 
 const {Downloader, Downloadable,
        MILLIS_IN_SECOND, MILLIS_IN_MINUTE,
        MILLIS_IN_HOUR, MILLIS_IN_DAY} = require("./downloader");
 const {Filter} = require("./filterClasses");
-const {FilterStorage} = require("./filterStorage");
+const {filterStorage} = require("./filterStorage");
 const {filterNotifier} = require("./filterNotifier");
 const {Prefs} = require("prefs");
 const {Subscription,
        DownloadableSubscription} = require("./subscriptionClasses");
 
 const INITIAL_DELAY = 1 * MILLIS_IN_MINUTE;
 const CHECK_INTERVAL = 1 * MILLIS_IN_HOUR;
 const DEFAULT_EXPIRATION_INTERVAL = 5 * MILLIS_IN_DAY;
@@ -90,17 +90,17 @@
    * downloaded.
    * @yields {Downloadable}
    */
   *_getDownloadables()
   {
     if (!Prefs.subscriptions_autoupdate)
       return;
 
-    for (let subscription of FilterStorage.subscriptions())
+    for (let subscription of filterStorage.subscriptions())
     {
       if (subscription instanceof DownloadableSubscription)
         yield this._getDownloadable(subscription, false);
     }
   }
 
   /**
    * Creates a {@link Downloadable} instance for a subscription.
@@ -181,24 +181,24 @@
     if (downloadable.redirectURL &&
         downloadable.redirectURL != downloadable.url)
     {
       let oldSubscription = Subscription.fromURL(downloadable.url);
       subscription.title = oldSubscription.title;
       subscription.disabled = oldSubscription.disabled;
       subscription.lastCheck = oldSubscription.lastCheck;
 
-      let listed = FilterStorage.knownSubscriptions.has(oldSubscription.url);
+      let listed = filterStorage.knownSubscriptions.has(oldSubscription.url);
       if (listed)
-        FilterStorage.removeSubscription(oldSubscription);
+        filterStorage.removeSubscription(oldSubscription);
 
       Subscription.knownSubscriptions.delete(oldSubscription.url);
 
       if (listed)
-        FilterStorage.addSubscription(subscription);
+        filterStorage.addSubscription(subscription);
     }
 
     // The download actually succeeded
     subscription.lastSuccess = subscription.lastDownload = Math.round(
       Date.now() / MILLIS_IN_SECOND
     );
     subscription.downloadStatus = "synchronize_ok";
     subscription.downloadCount = downloadable.downloadCount;
@@ -262,17 +262,17 @@
     let filters = [];
     for (let line of lines)
     {
       line = Filter.normalize(line);
       if (line)
         filters.push(Filter.fromText(line));
     }
 
-    FilterStorage.updateSubscriptionFilters(subscription, filters);
+    filterStorage.updateSubscriptionFilters(subscription, filters);
   }
 
   _onDownloadError(downloadable, downloadURL, error, channelStatus,
                    responseStatus, redirectCallback)
   {
     let subscription = Subscription.fromURL(downloadable.url);
     subscription.lastDownload = Math.round(Date.now() / MILLIS_IN_SECOND);
     subscription.downloadStatus = error;
@@ -310,17 +310,17 @@
         request.channel.loadFlags = request.channel.loadFlags |
                                     request.channel.INHIBIT_CACHING |
                                     request.channel.VALIDATE_ALWAYS;
         request.addEventListener("load", ev =>
         {
           if (onShutdown.done)
             return;
 
-          if (!FilterStorage.knownSubscriptions.has(subscription.url))
+          if (!filterStorage.knownSubscriptions.has(subscription.url))
             return;
 
           let match = /^(\d+)(?:\s+(\S+))?$/.exec(request.responseText);
           if (match && match[1] == "301" &&    // Moved permanently
               match[2] && /^https?:\/\//i.test(match[2]))
           {
             redirectCallback(match[2]);
           }
Index: test/filterListener.js
===================================================================
--- a/test/filterListener.js
+++ b/test/filterListener.js
@@ -15,17 +15,17 @@
  * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 "use strict";
 
 const {createSandbox} = require("./_common");
 let sandboxedRequire = null;
 
-let FilterStorage = null;
+let filterStorage = null;
 let Subscription = null;
 let Filter = null;
 let defaultMatcher = null;
 let SpecialSubscription = null;
 
 exports.setUp = function(callback)
 {
   sandboxedRequire = createSandbox({
@@ -37,25 +37,25 @@
     }
   });
 
   // We need to require the filterListener module so that filter changes will be
   // noticed, even though we don't directly use the module here.
   sandboxedRequire("../lib/filterListener");
 
   (
-    {FilterStorage} = sandboxedRequire("../lib/filterStorage"),
+    {filterStorage} = sandboxedRequire("../lib/filterStorage"),
     {Subscription, SpecialSubscription} = sandboxedRequire("../lib/subscriptionClasses"),
     {Filter} = sandboxedRequire("../lib/filterClasses"),
     {defaultMatcher} = sandboxedRequire("../lib/matcher")
   );
 
-  FilterStorage.addSubscription(Subscription.fromURL("~fl~"));
-  FilterStorage.addSubscription(Subscription.fromURL("~wl~"));
-  FilterStorage.addSubscription(Subscription.fromURL("~eh~"));
+  filterStorage.addSubscription(Subscription.fromURL("~fl~"));
+  filterStorage.addSubscription(Subscription.fromURL("~wl~"));
+  filterStorage.addSubscription(Subscription.fromURL("~eh~"));
 
   Subscription.fromURL("~fl~").defaults = ["blocking"];
   Subscription.fromURL("~wl~").defaults = ["whitelist"];
   Subscription.fromURL("~eh~").defaults = ["elemhide"];
 
   callback();
 };
 
@@ -117,38 +117,38 @@
   let filter1 = Filter.fromText("filter1");
   let filter2 = Filter.fromText("@@filter2");
   let filter3 = Filter.fromText("##filter3");
   let filter4 = Filter.fromText("!filter4");
   let filter5 = Filter.fromText("#@#filter5");
   let filter6 = Filter.fromText("example.com#?#:-abp-properties(filter6')");
   let filter7 = Filter.fromText("example.com#@#[-abp-properties='filter7']");
 
-  FilterStorage.addFilter(filter1);
+  filterStorage.addFilter(filter1);
   checkKnownFilters(test, "add filter1", {blacklist: [filter1.text]});
-  FilterStorage.addFilter(filter2);
+  filterStorage.addFilter(filter2);
   checkKnownFilters(test, "add @@filter2", {blacklist: [filter1.text], whitelist: [filter2.text]});
-  FilterStorage.addFilter(filter3);
+  filterStorage.addFilter(filter3);
   checkKnownFilters(test, "add ##filter3", {blacklist: [filter1.text], whitelist: [filter2.text], elemhide: [filter3.text]});
-  FilterStorage.addFilter(filter4);
+  filterStorage.addFilter(filter4);
   checkKnownFilters(test, "add !filter4", {blacklist: [filter1.text], whitelist: [filter2.text], elemhide: [filter3.text]});
-  FilterStorage.addFilter(filter5);
+  filterStorage.addFilter(filter5);
   checkKnownFilters(test, "add #@#filter5", {blacklist: [filter1.text], whitelist: [filter2.text], elemhide: [filter3.text], elemhideexception: [filter5.text]});
-  FilterStorage.addFilter(filter6);
+  filterStorage.addFilter(filter6);
   checkKnownFilters(test, "add example.com##:-abp-properties(filter6)", {blacklist: [filter1.text], whitelist: [filter2.text], elemhide: [filter3.text], elemhideexception: [filter5.text], elemhideemulation: [filter6.text]});
-  FilterStorage.addFilter(filter7);
+  filterStorage.addFilter(filter7);
   checkKnownFilters(test, "add example.com#@#[-abp-properties='filter7']", {blacklist: [filter1.text], whitelist: [filter2.text], elemhide: [filter3.text], elemhideexception: [filter5.text, filter7.text], elemhideemulation: [filter6.text]});
 
-  FilterStorage.removeFilter(filter1);
+  filterStorage.removeFilter(filter1);
   checkKnownFilters(test, "remove filter1", {whitelist: [filter2.text], elemhide: [filter3.text], elemhideexception: [filter5.text, filter7.text], elemhideemulation: [filter6.text]});
   filter2.disabled = true;
   checkKnownFilters(test, "disable filter2", {elemhide: [filter3.text], elemhideexception: [filter5.text, filter7.text], elemhideemulation: [filter6.text]});
-  FilterStorage.removeFilter(filter2);
+  filterStorage.removeFilter(filter2);
   checkKnownFilters(test, "remove filter2", {elemhide: [filter3.text], elemhideexception: [filter5.text, filter7.text], elemhideemulation: [filter6.text]});
-  FilterStorage.removeFilter(filter4);
+  filterStorage.removeFilter(filter4);
   checkKnownFilters(test, "remove filter4", {elemhide: [filter3.text], elemhideexception: [filter5.text, filter7.text], elemhideemulation: [filter6.text]});
 
   test.done();
 };
 
 exports.testDisablingEnablingFiltersNotInTheList = function(test)
 {
   let filter1 = Filter.fromText("filter1");
@@ -200,133 +200,133 @@
   let filter4 = Filter.fromText("!filter4");
   let filter5 = Filter.fromText("#@#filter5");
   let filter6 = Filter.fromText("example.com#?#:-abp-properties(filter6)");
   let filter7 = Filter.fromText("example.com#@#[-abp-properties='filter7']");
 
   let subscription = Subscription.fromURL("http://test1/");
   subscription.filters = [filter1, filter2, filter3, filter4, filter5, filter6, filter7];
 
-  FilterStorage.addSubscription(subscription);
+  filterStorage.addSubscription(subscription);
   checkKnownFilters(test, "add subscription with filter1, @@filter2, ##filter3, !filter4, #@#filter5, example.com#?#:-abp-properties(filter6), example.com#@#[-abp-properties='filter7']", {blacklist: [filter1.text], elemhide: [filter3.text], elemhideexception: [filter5.text, filter7.text], elemhideemulation: [filter6.text]});
 
   filter2.disabled = false;
   checkKnownFilters(test, "enable @@filter2", {blacklist: [filter1.text], whitelist: [filter2.text], elemhide: [filter3.text], elemhideexception: [filter5.text, filter7.text], elemhideemulation: [filter6.text]});
 
-  FilterStorage.addFilter(filter1);
+  filterStorage.addFilter(filter1);
   checkKnownFilters(test, "add filter1", {blacklist: [filter1.text], whitelist: [filter2.text], elemhide: [filter3.text], elemhideexception: [filter5.text, filter7.text], elemhideemulation: [filter6.text]});
 
-  FilterStorage.updateSubscriptionFilters(subscription, [filter4]);
+  filterStorage.updateSubscriptionFilters(subscription, [filter4]);
   checkKnownFilters(test, "change subscription filters to filter4", {blacklist: [filter1.text]});
 
-  FilterStorage.removeFilter(filter1);
+  filterStorage.removeFilter(filter1);
   checkKnownFilters(test, "remove filter1", {});
 
-  FilterStorage.updateSubscriptionFilters(subscription, [filter1, filter2]);
+  filterStorage.updateSubscriptionFilters(subscription, [filter1, filter2]);
   checkKnownFilters(test, "change subscription filters to filter1, filter2", {blacklist: [filter1.text], whitelist: [filter2.text]});
 
   filter1.disabled = true;
   checkKnownFilters(test, "disable filter1", {whitelist: [filter2.text]});
   filter2.disabled = true;
   checkKnownFilters(test, "disable filter2", {});
   filter1.disabled = false;
   filter2.disabled = false;
   checkKnownFilters(test, "enable filter1, filter2", {blacklist: [filter1.text], whitelist: [filter2.text]});
 
-  FilterStorage.addFilter(filter1);
+  filterStorage.addFilter(filter1);
   checkKnownFilters(test, "add filter1", {blacklist: [filter1.text], whitelist: [filter2.text]});
 
   subscription.disabled = true;
   checkKnownFilters(test, "disable subscription", {blacklist: [filter1.text]});
 
-  FilterStorage.removeSubscription(subscription);
+  filterStorage.removeSubscription(subscription);
   checkKnownFilters(test, "remove subscription", {blacklist: [filter1.text]});
 
-  FilterStorage.addSubscription(subscription);
+  filterStorage.addSubscription(subscription);
   checkKnownFilters(test, "add subscription", {blacklist: [filter1.text]});
 
   subscription.disabled = false;
   checkKnownFilters(test, "enable subscription", {blacklist: [filter1.text], whitelist: [filter2.text]});
 
   subscription.disabled = true;
   checkKnownFilters(test, "disable subscription", {blacklist: [filter1.text]});
 
-  FilterStorage.addFilter(filter2);
+  filterStorage.addFilter(filter2);
   checkKnownFilters(test, "add filter2", {blacklist: [filter1.text], whitelist: [filter2.text]});
 
-  FilterStorage.removeFilter(filter2);
+  filterStorage.removeFilter(filter2);
   checkKnownFilters(test, "remove filter2", {blacklist: [filter1.text]});
 
   subscription.disabled = false;
   checkKnownFilters(test, "enable subscription", {blacklist: [filter1.text], whitelist: [filter2.text]});
 
-  FilterStorage.removeSubscription(subscription);
+  filterStorage.removeSubscription(subscription);
   checkKnownFilters(test, "remove subscription", {blacklist: [filter1.text]});
 
   test.done();
 };
 
 exports.testFilterGroupOperations = function(test)
 {
   let filter1 = Filter.fromText("filter1");
   let filter2 = Filter.fromText("@@filter2");
   let filter3 = Filter.fromText("filter3");
   let filter4 = Filter.fromText("@@filter4");
   let filter5 = Filter.fromText("!filter5");
 
   let subscription = Subscription.fromURL("http://test1/");
   subscription.filters = [filter1, filter2];
 
-  FilterStorage.addSubscription(subscription);
-  FilterStorage.addFilter(filter1);
+  filterStorage.addSubscription(subscription);
+  filterStorage.addFilter(filter1);
   checkKnownFilters(test, "initial setup", {blacklist: [filter1.text], whitelist: [filter2.text]});
 
   let subscription2 = Subscription.fromURL("~fl~");
   subscription2.disabled = true;
   checkKnownFilters(test, "disable blocking filters", {blacklist: [filter1.text], whitelist: [filter2.text]});
 
-  FilterStorage.removeSubscription(subscription);
+  filterStorage.removeSubscription(subscription);
   checkKnownFilters(test, "remove subscription", {});
 
   subscription2.disabled = false;
   checkKnownFilters(test, "enable blocking filters", {blacklist: [filter1.text]});
 
   let subscription3 = Subscription.fromURL("~wl~");
   subscription3.disabled = true;
   checkKnownFilters(test, "disable exception rules", {blacklist: [filter1.text]});
 
-  FilterStorage.addFilter(filter2);
+  filterStorage.addFilter(filter2);
   checkKnownFilters(test, "add @@filter2", {blacklist: [filter1.text], whitelist: [filter2.text]});
   test.equal(filter2.subscriptionCount, 1, "@@filter2.subscriptionCount");
   test.ok([...filter2.subscriptions()][0] instanceof SpecialSubscription, "@@filter2 added to a new filter group");
   test.ok([...filter2.subscriptions()][0] != subscription3, "@@filter2 filter group is not the disabled exceptions group");
 
   subscription3.disabled = false;
   checkKnownFilters(test, "enable exception rules", {blacklist: [filter1.text], whitelist: [filter2.text]});
 
-  FilterStorage.removeFilter(filter2);
-  FilterStorage.addFilter(filter2);
+  filterStorage.removeFilter(filter2);
+  filterStorage.addFilter(filter2);
   checkKnownFilters(test, "re-add @@filter2", {blacklist: [filter1.text], whitelist: [filter2.text]});
   test.equal(filter2.subscriptionCount, 1, "@@filter2.subscriptionCount");
   test.ok([...filter2.subscriptions()][0] == subscription3, "@@filter2 added to the default exceptions group");
 
   let subscription4 = Subscription.fromURL("http://test/");
-  FilterStorage.updateSubscriptionFilters(subscription4, [filter3, filter4, filter5]);
+  filterStorage.updateSubscriptionFilters(subscription4, [filter3, filter4, filter5]);
   checkKnownFilters(test, "update subscription not in the list yet", {blacklist: [filter1.text], whitelist: [filter2.text]});
 
-  FilterStorage.addSubscription(subscription4);
+  filterStorage.addSubscription(subscription4);
   checkKnownFilters(test, "add subscription to the list", {blacklist: [filter1.text, filter3.text], whitelist: [filter2.text, filter4.text]});
 
-  FilterStorage.updateSubscriptionFilters(subscription4, [filter3, filter2, filter5]);
+  filterStorage.updateSubscriptionFilters(subscription4, [filter3, filter2, filter5]);
   checkKnownFilters(test, "update subscription while in the list", {blacklist: [filter1.text, filter3.text], whitelist: [filter2.text]});
 
   subscription3.disabled = true;
   checkKnownFilters(test, "disable exception rules", {blacklist: [filter1.text, filter3.text], whitelist: [filter2.text]});
 
-  FilterStorage.removeSubscription(subscription4);
+  filterStorage.removeSubscription(subscription4);
   checkKnownFilters(test, "remove subscription from the list", {blacklist: [filter1.text]});
 
   subscription3.disabled = false;
   checkKnownFilters(test, "enable exception rules", {blacklist: [filter1.text], whitelist: [filter2.text]});
 
   test.done();
 };
 
@@ -334,32 +334,32 @@
 {
   let filter1 = Filter.fromText("example.com#$#filter1");
   let filter2 = Filter.fromText("example.com#$#filter2");
   let filter3 = Filter.fromText("example.com#$#filter3");
 
   let subscription1 = Subscription.fromURL("http://test1/");
   subscription1.filters = [filter1, filter2];
 
-  FilterStorage.addSubscription(subscription1);
+  filterStorage.addSubscription(subscription1);
   checkKnownFilters(test, "add subscription with filter1 and filter2", {});
 
   let subscription2 = Subscription.fromURL("http://test2/");
   subscription2.type = "circumvention";
   subscription2.filters = [filter1];
 
-  FilterStorage.addSubscription(subscription2);
+  filterStorage.addSubscription(subscription2);
   checkKnownFilters(test, "add subscription of type circumvention with filter1", {snippets: [filter1.text]});
 
   let subscription3 = Subscription.fromURL("~foo");
   subscription3.filters = [filter2];
 
-  FilterStorage.addSubscription(subscription3);
+  filterStorage.addSubscription(subscription3);
   checkKnownFilters(test, "add special subscription with filter2", {snippets: [filter1.text, filter2.text]});
 
   let subscription4 = Subscription.fromURL("https://easylist-downloads.adblockplus.org/abp-filters-anti-cv.txt");
   subscription4.filters = [filter3];
 
-  FilterStorage.addSubscription(subscription4);
+  filterStorage.addSubscription(subscription4);
   checkKnownFilters(test, "add ABP anti-circumvention subscription with filter3", {snippets: [filter1.text, filter2.text, filter3.text]});
 
   test.done();
 };
Index: test/filterStorage.js
===================================================================
--- a/test/filterStorage.js
+++ b/test/filterStorage.js
@@ -16,28 +16,28 @@
  */
 
 "use strict";
 
 const {createSandbox} = require("./_common");
 
 let Filter = null;
 let filterNotifier = null;
-let FilterStorage = null;
+let filterStorage = null;
 let Subscription = null;
 
 exports.setUp = function(callback)
 {
   let sandboxedRequire = createSandbox();
 
   sandboxedRequire("../lib/filterListener");
   (
     {Filter} = sandboxedRequire("../lib/filterClasses"),
     {filterNotifier} = sandboxedRequire("../lib/filterNotifier"),
-    {FilterStorage} = sandboxedRequire("../lib/filterStorage"),
+    {filterStorage} = sandboxedRequire("../lib/filterStorage"),
     {Subscription} = sandboxedRequire("../lib/subscriptionClasses")
   );
 
   callback();
 };
 
 function addListener(listener)
 {
@@ -53,30 +53,30 @@
 
   filterNotifier.on("filter.hitCount", makeWrapper("filter.hitCount"));
   filterNotifier.on("filter.lastHit", makeWrapper("filter.lastHit"));
 }
 
 function compareSubscriptionList(test, testMessage, list,
                                  knownSubscriptions = null)
 {
-  let result = [...FilterStorage.knownSubscriptions.keys()];
+  let result = [...filterStorage.knownSubscriptions.keys()];
   let expected = list.map(subscription => subscription.url);
   test.deepEqual(result, expected, testMessage);
 
   if (knownSubscriptions)
   {
     test.deepEqual([...Subscription.knownSubscriptions.values()],
                    knownSubscriptions, testMessage);
   }
 }
 
 function compareFiltersList(test, testMessage, list)
 {
-  let result = [...FilterStorage.subscriptions()].map(
+  let result = [...filterStorage.subscriptions()].map(
     subscription => subscription.filters.map(
       filter => filter.text));
   test.deepEqual(result, list, testMessage);
 }
 
 function compareFilterSubscriptions(test, testMessage, filter, list)
 {
   let result = [...filter.subscriptions()].map(subscription => subscription.url);
@@ -96,51 +96,51 @@
       changes.push(action + " " + subscription.url);
   }
   addListener(listener);
 
   compareSubscriptionList(test, "Initial state", []);
   test.deepEqual(changes, [], "Received changes");
 
   changes = [];
-  FilterStorage.addSubscription(subscription1);
+  filterStorage.addSubscription(subscription1);
   compareSubscriptionList(test, "Adding first subscription", [subscription1]);
   test.deepEqual(changes, ["subscription.added http://test1/"], "Received changes");
 
   changes = [];
-  FilterStorage.addSubscription(subscription1);
+  filterStorage.addSubscription(subscription1);
   compareSubscriptionList(test, "Adding already added subscription", [subscription1]);
   test.deepEqual(changes, [], "Received changes");
 
   changes = [];
-  FilterStorage.addSubscription(subscription2);
+  filterStorage.addSubscription(subscription2);
   compareSubscriptionList(test, "Adding second", [subscription1, subscription2]);
   test.deepEqual(changes, ["subscription.added http://test2/"], "Received changes");
 
-  FilterStorage.removeSubscription(subscription1);
+  filterStorage.removeSubscription(subscription1);
   compareSubscriptionList(test, "Remove", [subscription2]);
 
   changes = [];
-  FilterStorage.addSubscription(subscription1);
+  filterStorage.addSubscription(subscription1);
   compareSubscriptionList(test, "Re-adding previously removed subscription", [subscription2, subscription1]);
   test.deepEqual(changes, ["subscription.added http://test1/"], "Received changes");
 
   test.done();
 };
 
 exports.testRemovingSubscriptions = function(test)
 {
   let subscription1 = Subscription.fromURL("http://test1/");
   let subscription2 = Subscription.fromURL("http://test2/");
 
   test.equal(Subscription.fromURL(subscription1.url), subscription1,
              "Subscription known before addition");
 
-  FilterStorage.addSubscription(subscription1);
-  FilterStorage.addSubscription(subscription2);
+  filterStorage.addSubscription(subscription1);
+  filterStorage.addSubscription(subscription2);
 
   let changes = [];
   function listener(action, subscription)
   {
     if (action.indexOf("subscription.") == 0)
       changes.push(action + " " + subscription.url);
   }
   addListener(listener);
@@ -148,145 +148,145 @@
   compareSubscriptionList(test, "Initial state", [subscription1, subscription2],
                           [subscription1, subscription2]);
   test.deepEqual(changes, [], "Received changes");
 
   test.equal(Subscription.fromURL(subscription1.url), subscription1,
              "Subscription known after addition");
 
   changes = [];
-  FilterStorage.removeSubscription(subscription1);
+  filterStorage.removeSubscription(subscription1);
   compareSubscriptionList(test, "Removing first subscription", [subscription2],
                           [subscription2]);
   test.deepEqual(changes, ["subscription.removed http://test1/"], "Received changes");
 
   // Once a subscription has been removed, it is forgotten; a new object is
   // created for the previously known subscription URL.
   test.notEqual(Subscription.fromURL(subscription1.url), subscription1,
                 "Subscription forgotten upon removal");
   Subscription.knownSubscriptions.delete(subscription1.url);
 
   changes = [];
-  FilterStorage.removeSubscription(subscription1);
+  filterStorage.removeSubscription(subscription1);
   compareSubscriptionList(test, "Removing already removed subscription", [subscription2],
                           [subscription2]);
   test.deepEqual(changes, [], "Received changes");
 
   changes = [];
-  FilterStorage.removeSubscription(subscription2);
+  filterStorage.removeSubscription(subscription2);
   compareSubscriptionList(test, "Removing remaining subscription", [], []);
   test.deepEqual(changes, ["subscription.removed http://test2/"], "Received changes");
 
-  FilterStorage.addSubscription(subscription1);
+  filterStorage.addSubscription(subscription1);
   compareSubscriptionList(test, "Add", [subscription1], []);
 
   changes = [];
-  FilterStorage.removeSubscription(subscription1);
+  filterStorage.removeSubscription(subscription1);
   compareSubscriptionList(test, "Re-removing previously added subscription", [], []);
   test.deepEqual(changes, ["subscription.removed http://test1/"], "Received changes");
 
   test.done();
 };
 
 exports.testMovingSubscriptions = function(test)
 {
   let subscription1 = Subscription.fromURL("http://test1/");
   let subscription2 = Subscription.fromURL("http://test2/");
   let subscription3 = Subscription.fromURL("http://test3/");
 
-  FilterStorage.addSubscription(subscription1);
-  FilterStorage.addSubscription(subscription2);
-  FilterStorage.addSubscription(subscription3);
+  filterStorage.addSubscription(subscription1);
+  filterStorage.addSubscription(subscription2);
+  filterStorage.addSubscription(subscription3);
 
   let changes = [];
   function listener(action, subscription)
   {
     if (action.indexOf("subscription.") == 0)
       changes.push(action + " " + subscription.url);
   }
   addListener(listener);
 
   compareSubscriptionList(test, "Initial state", [subscription1, subscription2, subscription3]);
   test.deepEqual(changes, [], "Received changes");
 
-  FilterStorage.removeSubscription(subscription2);
+  filterStorage.removeSubscription(subscription2);
   compareSubscriptionList(test, "Remove", [subscription1, subscription3]);
 
   test.done();
 };
 
 exports.testAddingFilters = function(test)
 {
   let subscription1 = Subscription.fromURL("~blocking");
   subscription1.defaults = ["blocking"];
 
   let subscription2 = Subscription.fromURL("~exceptions");
   subscription2.defaults = ["whitelist", "elemhide"];
 
   let subscription3 = Subscription.fromURL("~other");
 
-  FilterStorage.addSubscription(subscription1);
-  FilterStorage.addSubscription(subscription2);
-  FilterStorage.addSubscription(subscription3);
+  filterStorage.addSubscription(subscription1);
+  filterStorage.addSubscription(subscription2);
+  filterStorage.addSubscription(subscription3);
 
   let changes = [];
   function listener(action, filter)
   {
     if (action.indexOf("filter.") == 0)
       changes.push(action + " " + filter.text);
   }
   addListener(listener);
 
   compareFiltersList(test, "Initial state", [[], [], []]);
   test.deepEqual(changes, [], "Received changes");
 
   changes = [];
-  FilterStorage.addFilter(Filter.fromText("foo"));
+  filterStorage.addFilter(Filter.fromText("foo"));
   compareFiltersList(test, "Adding blocking filter", [["foo"], [], []]);
   test.deepEqual(changes, ["filter.added foo"], "Received changes");
 
   changes = [];
-  FilterStorage.addFilter(Filter.fromText("@@bar"));
+  filterStorage.addFilter(Filter.fromText("@@bar"));
   compareFiltersList(test, "Adding exception rule", [["foo"], ["@@bar"], []]);
   test.deepEqual(changes, ["filter.added @@bar"], "Received changes");
 
   changes = [];
-  FilterStorage.addFilter(Filter.fromText("foo##bar"));
+  filterStorage.addFilter(Filter.fromText("foo##bar"));
   compareFiltersList(test, "Adding hiding rule", [["foo"], ["@@bar", "foo##bar"], []]);
   test.deepEqual(changes, ["filter.added foo##bar"], "Received changes");
 
   changes = [];
-  FilterStorage.addFilter(Filter.fromText("foo#@#bar"));
+  filterStorage.addFilter(Filter.fromText("foo#@#bar"));
   compareFiltersList(test, "Adding hiding exception", [["foo"], ["@@bar", "foo##bar", "foo#@#bar"], []]);
   test.deepEqual(changes, ["filter.added foo#@#bar"], "Received changes");
 
   changes = [];
-  FilterStorage.addFilter(Filter.fromText("!foobar"));
+  filterStorage.addFilter(Filter.fromText("!foobar"));
   compareFiltersList(test, "Adding comment", [["foo"], ["@@bar", "foo##bar", "foo#@#bar"], ["!foobar"]]);
   test.deepEqual(changes, ["filter.added !foobar"], "Received changes");
 
   changes = [];
-  FilterStorage.addFilter(Filter.fromText("foo"));
+  filterStorage.addFilter(Filter.fromText("foo"));
   compareFiltersList(test, "Adding already added filter", [["foo"], ["@@bar", "foo##bar", "foo#@#bar"], ["!foobar"]]);
   test.deepEqual(changes, [], "Received changes");
 
   subscription1.disabled = true;
 
   changes = [];
-  FilterStorage.addFilter(Filter.fromText("foo"));
+  filterStorage.addFilter(Filter.fromText("foo"));
   compareFiltersList(test, "Adding filter already in a disabled subscription", [["foo"], ["@@bar", "foo##bar", "foo#@#bar"], ["!foobar", "foo"]]);
   test.deepEqual(changes, ["filter.added foo"], "Received changes");
 
   changes = [];
-  FilterStorage.addFilter(Filter.fromText("foo"), subscription1);
+  filterStorage.addFilter(Filter.fromText("foo"), subscription1);
   compareFiltersList(test, "Adding filter to an explicit subscription", [["foo", "foo"], ["@@bar", "foo##bar", "foo#@#bar"], ["!foobar", "foo"]]);
   test.deepEqual(changes, ["filter.added foo"], "Received changes");
 
   changes = [];
-  FilterStorage.addFilter(Filter.fromText("!foobar"), subscription2, 0);
+  filterStorage.addFilter(Filter.fromText("!foobar"), subscription2, 0);
   compareFiltersList(test, "Adding filter to an explicit subscription with position", [["foo", "foo"], ["!foobar", "@@bar", "foo##bar", "foo#@#bar"], ["!foobar", "foo"]]);
   test.deepEqual(changes, ["filter.added !foobar"], "Received changes");
 
   test.done();
 };
 
 exports.testRemovingFilters = function(test)
 {
@@ -294,108 +294,108 @@
   subscription1.filters = [Filter.fromText("foo"), Filter.fromText("foo"), Filter.fromText("bar")];
 
   let subscription2 = Subscription.fromURL("~bar");
   subscription2.filters = [Filter.fromText("foo"), Filter.fromText("bar"), Filter.fromText("foo")];
 
   let subscription3 = Subscription.fromURL("http://test/");
   subscription3.filters = [Filter.fromText("foo"), Filter.fromText("bar")];
 
-  FilterStorage.addSubscription(subscription1);
-  FilterStorage.addSubscription(subscription2);
-  FilterStorage.addSubscription(subscription3);
+  filterStorage.addSubscription(subscription1);
+  filterStorage.addSubscription(subscription2);
+  filterStorage.addSubscription(subscription3);
 
   let changes = [];
   function listener(action, filter)
   {
     if (action.indexOf("filter.") == 0)
       changes.push(action + " " + filter.text);
   }
   addListener(listener);
 
   compareFiltersList(test, "Initial state", [["foo", "foo", "bar"], ["foo", "bar", "foo"], ["foo", "bar"]]);
   test.deepEqual(changes, [], "Received changes");
 
   changes = [];
-  FilterStorage.removeFilter(Filter.fromText("foo"), subscription2, 0);
+  filterStorage.removeFilter(Filter.fromText("foo"), subscription2, 0);
   compareFiltersList(test, "Remove with explicit subscription and position", [["foo", "foo", "bar"], ["bar", "foo"], ["foo", "bar"]]);
   test.deepEqual(changes, ["filter.removed foo"], "Received changes");
 
   changes = [];
-  FilterStorage.removeFilter(Filter.fromText("foo"), subscription2, 0);
+  filterStorage.removeFilter(Filter.fromText("foo"), subscription2, 0);
   compareFiltersList(test, "Remove with explicit subscription and wrong position", [["foo", "foo", "bar"], ["bar", "foo"], ["foo", "bar"]]);
   test.deepEqual(changes, [], "Received changes");
 
   changes = [];
-  FilterStorage.removeFilter(Filter.fromText("foo"), subscription1);
+  filterStorage.removeFilter(Filter.fromText("foo"), subscription1);
   compareFiltersList(test, "Remove with explicit subscription", [["bar"], ["bar", "foo"], ["foo", "bar"]]);
   test.deepEqual(changes, ["filter.removed foo", "filter.removed foo"], "Received changes");
 
   changes = [];
-  FilterStorage.removeFilter(Filter.fromText("foo"), subscription1);
+  filterStorage.removeFilter(Filter.fromText("foo"), subscription1);
   compareFiltersList(test, "Remove from subscription not having the filter", [["bar"], ["bar", "foo"], ["foo", "bar"]]);
   test.deepEqual(changes, [], "Received changes");
 
   changes = [];
-  FilterStorage.removeFilter(Filter.fromText("bar"));
+  filterStorage.removeFilter(Filter.fromText("bar"));
   compareFiltersList(test, "Remove everywhere", [[], ["foo"], ["foo", "bar"]]);
   test.deepEqual(changes, ["filter.removed bar", "filter.removed bar"], "Received changes");
 
   changes = [];
-  FilterStorage.removeFilter(Filter.fromText("bar"));
+  filterStorage.removeFilter(Filter.fromText("bar"));
   compareFiltersList(test, "Remove of unknown filter", [[], ["foo"], ["foo", "bar"]]);
   test.deepEqual(changes, [], "Received changes");
 
   test.done();
 };
 
 exports.testMovingFilters = function(test)
 {
   let subscription1 = Subscription.fromURL("~foo");
   subscription1.filters = [Filter.fromText("foo"), Filter.fromText("bar"), Filter.fromText("bas"), Filter.fromText("foo")];
 
   let subscription2 = Subscription.fromURL("http://test/");
   subscription2.filters = [Filter.fromText("foo"), Filter.fromText("bar")];
 
-  FilterStorage.addSubscription(subscription1);
-  FilterStorage.addSubscription(subscription2);
+  filterStorage.addSubscription(subscription1);
+  filterStorage.addSubscription(subscription2);
 
   let changes = [];
   function listener(action, filter)
   {
     if (action.indexOf("filter.") == 0)
       changes.push(action + " " + filter.text);
   }
   addListener(listener);
 
   compareFiltersList(test, "Initial state", [["foo", "bar", "bas", "foo"], ["foo", "bar"]]);
   test.deepEqual(changes, [], "Received changes");
 
   changes = [];
-  FilterStorage.moveFilter(Filter.fromText("foo"), subscription1, 0, 1);
+  filterStorage.moveFilter(Filter.fromText("foo"), subscription1, 0, 1);
   compareFiltersList(test, "Regular move", [["bar", "foo", "bas", "foo"], ["foo", "bar"]]);
   test.deepEqual(changes, ["filter.moved foo"], "Received changes");
 
   changes = [];
-  FilterStorage.moveFilter(Filter.fromText("foo"), subscription1, 0, 3);
+  filterStorage.moveFilter(Filter.fromText("foo"), subscription1, 0, 3);
   compareFiltersList(test, "Invalid move", [["bar", "foo", "bas", "foo"], ["foo", "bar"]]);
   test.deepEqual(changes, [], "Received changes");
 
   changes = [];
-  FilterStorage.moveFilter(Filter.fromText("foo"), subscription2, 0, 1);
+  filterStorage.moveFilter(Filter.fromText("foo"), subscription2, 0, 1);
   compareFiltersList(test, "Invalid subscription", [["bar", "foo", "bas", "foo"], ["foo", "bar"]]);
   test.deepEqual(changes, [], "Received changes");
 
   changes = [];
-  FilterStorage.moveFilter(Filter.fromText("foo"), subscription1, 1, 1);
+  filterStorage.moveFilter(Filter.fromText("foo"), subscription1, 1, 1);
   compareFiltersList(test, "Move to current position", [["bar", "foo", "bas", "foo"], ["foo", "bar"]]);
   test.deepEqual(changes, [], "Received changes");
 
   changes = [];
-  FilterStorage.moveFilter(Filter.fromText("bar"), subscription1, 0, 1);
+  filterStorage.moveFilter(Filter.fromText("bar"), subscription1, 0, 1);
   compareFiltersList(test, "Regular move", [["foo", "bar", "bas", "foo"], ["foo", "bar"]]);
   test.deepEqual(changes, ["filter.moved bar"], "Received changes");
 
   test.done();
 };
 
 exports.testHitCounts = function(test)
 {
@@ -405,43 +405,43 @@
     if (action.indexOf("filter.") == 0)
       changes.push(action + " " + filter.text);
   }
   addListener(listener);
 
   let filter1 = Filter.fromText("filter1");
   let filter2 = Filter.fromText("filter2");
 
-  FilterStorage.addFilter(filter1);
+  filterStorage.addFilter(filter1);
 
   test.equal(filter1.hitCount, 0, "filter1 initial hit count");
   test.equal(filter2.hitCount, 0, "filter2 initial hit count");
   test.equal(filter1.lastHit, 0, "filter1 initial last hit");
   test.equal(filter2.lastHit, 0, "filter2 initial last hit");
 
   changes = [];
-  FilterStorage.increaseHitCount(filter1);
+  filterStorage.increaseHitCount(filter1);
   test.equal(filter1.hitCount, 1, "Hit count after increase (filter in list)");
   test.ok(filter1.lastHit > 0, "Last hit changed after increase");
   test.deepEqual(changes, ["filter.hitCount filter1", "filter.lastHit filter1"], "Received changes");
 
   changes = [];
-  FilterStorage.increaseHitCount(filter2);
+  filterStorage.increaseHitCount(filter2);
   test.equal(filter2.hitCount, 1, "Hit count after increase (filter not in list)");
   test.ok(filter2.lastHit > 0, "Last hit changed after increase");
   test.deepEqual(changes, ["filter.hitCount filter2", "filter.lastHit filter2"], "Received changes");
 
   changes = [];
-  FilterStorage.resetHitCounts([filter1]);
+  filterStorage.resetHitCounts([filter1]);
   test.equal(filter1.hitCount, 0, "Hit count after reset");
   test.equal(filter1.lastHit, 0, "Last hit after reset");
   test.deepEqual(changes, ["filter.hitCount filter1", "filter.lastHit filter1"], "Received changes");
 
   changes = [];
-  FilterStorage.resetHitCounts(null);
+  filterStorage.resetHitCounts(null);
   test.equal(filter2.hitCount, 0, "Hit count after complete reset");
   test.equal(filter2.lastHit, 0, "Last hit after complete reset");
   test.deepEqual(changes, ["filter.hitCount filter2", "filter.lastHit filter2"], "Received changes");
 
   test.done();
 };
 
 exports.testFilterSubscriptionRelationship = function(test)
@@ -458,52 +458,52 @@
 
   let subscription3 = Subscription.fromURL("http://test3/");
   subscription3.filters = [filter1, filter2, filter3];
 
   compareFilterSubscriptions(test, "Initial filter1 subscriptions", filter1, []);
   compareFilterSubscriptions(test, "Initial filter2 subscriptions", filter2, []);
   compareFilterSubscriptions(test, "Initial filter3 subscriptions", filter3, []);
 
-  FilterStorage.addSubscription(subscription1);
+  filterStorage.addSubscription(subscription1);
 
   compareFilterSubscriptions(test, "filter1 subscriptions after adding http://test1/", filter1, [subscription1]);
   compareFilterSubscriptions(test, "filter2 subscriptions after adding http://test1/", filter2, [subscription1]);
   compareFilterSubscriptions(test, "filter3 subscriptions after adding http://test1/", filter3, []);
 
-  FilterStorage.addSubscription(subscription2);
+  filterStorage.addSubscription(subscription2);
 
   compareFilterSubscriptions(test, "filter1 subscriptions after adding http://test2/", filter1, [subscription1]);
   compareFilterSubscriptions(test, "filter2 subscriptions after adding http://test2/", filter2, [subscription1, subscription2]);
   compareFilterSubscriptions(test, "filter3 subscriptions after adding http://test2/", filter3, [subscription2]);
 
-  FilterStorage.removeSubscription(subscription1);
+  filterStorage.removeSubscription(subscription1);
 
   compareFilterSubscriptions(test, "filter1 subscriptions after removing http://test1/", filter1, []);
   compareFilterSubscriptions(test, "filter2 subscriptions after removing http://test1/", filter2, [subscription2]);
   compareFilterSubscriptions(test, "filter3 subscriptions after removing http://test1/", filter3, [subscription2]);
 
-  FilterStorage.updateSubscriptionFilters(subscription3, [filter3]);
+  filterStorage.updateSubscriptionFilters(subscription3, [filter3]);
 
   compareFilterSubscriptions(test, "filter1 subscriptions after updating http://test3/ filters", filter1, []);
   compareFilterSubscriptions(test, "filter2 subscriptions after updating http://test3/ filters", filter2, [subscription2]);
   compareFilterSubscriptions(test, "filter3 subscriptions after updating http://test3/ filters", filter3, [subscription2]);
 
-  FilterStorage.addSubscription(subscription3);
+  filterStorage.addSubscription(subscription3);
 
   compareFilterSubscriptions(test, "filter1 subscriptions after adding http://test3/", filter1, []);
   compareFilterSubscriptions(test, "filter2 subscriptions after adding http://test3/", filter2, [subscription2]);
   compareFilterSubscriptions(test, "filter3 subscriptions after adding http://test3/", filter3, [subscription2, subscription3]);
 
-  FilterStorage.updateSubscriptionFilters(subscription3, [filter1, filter2]);
+  filterStorage.updateSubscriptionFilters(subscription3, [filter1, filter2]);
 
   compareFilterSubscriptions(test, "filter1 subscriptions after updating http://test3/ filters", filter1, [subscription3]);
   compareFilterSubscriptions(test, "filter2 subscriptions after updating http://test3/ filters", filter2, [subscription2, subscription3]);
   compareFilterSubscriptions(test, "filter3 subscriptions after updating http://test3/ filters", filter3, [subscription2]);
 
-  FilterStorage.removeSubscription(subscription3);
+  filterStorage.removeSubscription(subscription3);
 
   compareFilterSubscriptions(test, "filter1 subscriptions after removing http://test3/", filter1, []);
   compareFilterSubscriptions(test, "filter2 subscriptions after removing http://test3/", filter2, [subscription2]);
   compareFilterSubscriptions(test, "filter3 subscriptions after removing http://test3/", filter3, [subscription2]);
 
   test.done();
 };
Index: test/filterStorage_readwrite.js
===================================================================
--- a/test/filterStorage_readwrite.js
+++ b/test/filterStorage_readwrite.js
@@ -15,34 +15,34 @@
  * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 "use strict";
 
 const {createSandbox, unexpectedError} = require("./_common");
 
 let Filter = null;
-let FilterStorage = null;
+let filterStorage = null;
 let IO = null;
 let Prefs = null;
 let ExternalSubscription = null;
 let SpecialSubscription = null;
 
 exports.setUp = function(callback)
 {
   let sandboxedRequire = createSandbox();
   (
     {Filter} = sandboxedRequire("../lib/filterClasses"),
-    {FilterStorage} = sandboxedRequire("../lib/filterStorage"),
+    {filterStorage} = sandboxedRequire("../lib/filterStorage"),
     {IO} = sandboxedRequire("./stub-modules/io"),
     {Prefs} = sandboxedRequire("./stub-modules/prefs"),
     {ExternalSubscription, SpecialSubscription} = sandboxedRequire("../lib/subscriptionClasses")
   );
 
-  FilterStorage.addFilter(Filter.fromText("foobar"));
+  filterStorage.addFilter(Filter.fromText("foobar"));
   callback();
 };
 
 let testData = new Promise((resolve, reject) =>
 {
   const fs = require("fs");
   const path = require("path");
   let datapath = path.resolve(__dirname, "data", "patterns.ini");
@@ -88,60 +88,60 @@
       return 1;
     return 0;
   });
   return sections;
 }
 
 function testReadWrite(test, withExternal, withEmptySpecial)
 {
-  test.ok(!FilterStorage.initialized, "Uninitialized before the first load");
+  test.ok(!filterStorage.initialized, "Uninitialized before the first load");
 
   return testData.then(data =>
   {
-    IO._setFileContents(FilterStorage.sourceFile, data);
-    return FilterStorage.loadFromDisk();
+    IO._setFileContents(filterStorage.sourceFile, data);
+    return filterStorage.loadFromDisk();
   }).then(() =>
   {
-    test.ok(FilterStorage.initialized, "Initialize after the first load");
-    test.equal(FilterStorage.fileProperties.version, FilterStorage.formatVersion, "File format version");
+    test.ok(filterStorage.initialized, "Initialize after the first load");
+    test.equal(filterStorage.fileProperties.version, filterStorage.formatVersion, "File format version");
 
     if (withExternal)
     {
       {
         let subscription = new ExternalSubscription("~external~external subscription ID", "External subscription");
         subscription.filters = [Filter.fromText("foo"), Filter.fromText("bar")];
-        FilterStorage.addSubscription(subscription);
+        filterStorage.addSubscription(subscription);
       }
 
-      let externalSubscriptions = [...FilterStorage.subscriptions()].filter(subscription => subscription instanceof ExternalSubscription);
+      let externalSubscriptions = [...filterStorage.subscriptions()].filter(subscription => subscription instanceof ExternalSubscription);
       test.equal(externalSubscriptions.length, 1, "Number of external subscriptions after updateExternalSubscription");
 
       test.equal(externalSubscriptions[0].url, "~external~external subscription ID", "ID of external subscription");
       test.equal(externalSubscriptions[0].filters.length, 2, "Number of filters in external subscription");
     }
 
     if (withEmptySpecial)
     {
       let specialSubscription =
         SpecialSubscription.createForFilter(Filter.fromText("!foo"));
-      FilterStorage.addSubscription(specialSubscription);
+      filterStorage.addSubscription(specialSubscription);
 
-      FilterStorage.removeFilter(Filter.fromText("!foo"), specialSubscription);
+      filterStorage.removeFilter(Filter.fromText("!foo"), specialSubscription);
 
       test.equal(specialSubscription.filters.length, 0,
                  "No filters in special subscription");
-      test.ok(new Set(FilterStorage.subscriptions()).has(specialSubscription),
+      test.ok(new Set(filterStorage.subscriptions()).has(specialSubscription),
               "Empty special subscription still in storage");
     }
 
-    return FilterStorage.saveToDisk();
+    return filterStorage.saveToDisk();
   }).then(() => testData).then(expected =>
   {
-    test.deepEqual(canonize(IO._getFileContents(FilterStorage.sourceFile)),
+    test.deepEqual(canonize(IO._getFileContents(filterStorage.sourceFile)),
                canonize(expected), "Read/write result");
   }).catch(unexpectedError.bind(test)).then(() => test.done());
 }
 
 exports.testReadAndSaveToFile = function(test)
 {
   testReadWrite(test, false);
 };
@@ -158,115 +158,115 @@
 
 exports.testImportExport = function(test)
 {
   testData.then(lines =>
   {
     if (lines.length && lines[lines.length - 1] == "")
       lines.pop();
 
-    let importer = FilterStorage.importData();
+    let importer = filterStorage.importData();
     for (let line of lines)
       importer(line);
     importer(null);
 
-    test.equal(FilterStorage.fileProperties.version, FilterStorage.formatVersion, "File format version");
+    test.equal(filterStorage.fileProperties.version, filterStorage.formatVersion, "File format version");
 
-    let exported = Array.from(FilterStorage.exportData());
+    let exported = Array.from(filterStorage.exportData());
     test.deepEqual(canonize(exported), canonize(lines), "Import/export result");
   }).catch(unexpectedError.bind(test)).then(() => test.done());
 };
 
 exports.testSavingWithoutBackups = function(test)
 {
   Prefs.patternsbackups = 0;
   Prefs.patternsbackupinterval = 24;
 
-  FilterStorage.saveToDisk().then(() =>
+  filterStorage.saveToDisk().then(() =>
   {
-    return FilterStorage.saveToDisk();
+    return filterStorage.saveToDisk();
   }).then(() =>
   {
-    test.ok(!IO._getFileContents(FilterStorage.getBackupName(1)),
+    test.ok(!IO._getFileContents(filterStorage.getBackupName(1)),
             "Backup shouldn't be created");
   }).catch(unexpectedError.bind(test)).then(() => test.done());
 };
 
 exports.testSavingWithBackups = function(test)
 {
   Prefs.patternsbackups = 2;
   Prefs.patternsbackupinterval = 24;
 
-  let backupFile = FilterStorage.getBackupName(1);
-  let backupFile2 = FilterStorage.getBackupName(2);
-  let backupFile3 = FilterStorage.getBackupName(3);
+  let backupFile = filterStorage.getBackupName(1);
+  let backupFile2 = filterStorage.getBackupName(2);
+  let backupFile3 = filterStorage.getBackupName(3);
 
   let oldModifiedTime;
 
-  FilterStorage.saveToDisk().then(() =>
+  filterStorage.saveToDisk().then(() =>
   {
     // Save again immediately
-    return FilterStorage.saveToDisk();
+    return filterStorage.saveToDisk();
   }).then(() =>
   {
     test.ok(IO._getFileContents(backupFile), "First backup created");
 
     oldModifiedTime = IO._getModifiedTime(backupFile) - 10000;
     IO._setModifiedTime(backupFile, oldModifiedTime);
-    return FilterStorage.saveToDisk();
+    return filterStorage.saveToDisk();
   }).then(() =>
   {
     test.equal(IO._getModifiedTime(backupFile), oldModifiedTime, "Backup not overwritten if it is only 10 seconds old");
 
     oldModifiedTime -= 40 * 60 * 60 * 1000;
     IO._setModifiedTime(backupFile, oldModifiedTime);
-    return FilterStorage.saveToDisk();
+    return filterStorage.saveToDisk();
   }).then(() =>
   {
     test.notEqual(IO._getModifiedTime(backupFile), oldModifiedTime, "Backup overwritten if it is 40 hours old");
 
     test.ok(IO._getFileContents(backupFile2), "Second backup created when first backup is overwritten");
 
     IO._setModifiedTime(backupFile, IO._getModifiedTime(backupFile) - 20000);
     oldModifiedTime = IO._getModifiedTime(backupFile2);
-    return FilterStorage.saveToDisk();
+    return filterStorage.saveToDisk();
   }).then(() =>
   {
     test.equal(IO._getModifiedTime(backupFile2), oldModifiedTime, "Second backup not overwritten if first one is only 20 seconds old");
 
     IO._setModifiedTime(backupFile, IO._getModifiedTime(backupFile) - 25 * 60 * 60 * 1000);
     oldModifiedTime = IO._getModifiedTime(backupFile2);
-    return FilterStorage.saveToDisk();
+    return filterStorage.saveToDisk();
   }).then(() =>
   {
     test.notEqual(IO._getModifiedTime(backupFile2), oldModifiedTime, "Second backup overwritten if first one is 25 hours old");
 
     test.ok(!IO._getFileContents(backupFile3), "Third backup not created with patternsbackups = 2");
   }).catch(unexpectedError.bind(test)).then(() => test.done());
 };
 
 exports.testRestoringBackup = function(test)
 {
   Prefs.patternsbackups = 2;
   Prefs.patternsbackupinterval = 24;
 
-  FilterStorage.saveToDisk().then(() =>
+  filterStorage.saveToDisk().then(() =>
   {
-    test.equal([...FilterStorage.subscriptions()][0].filters.length, 1, "Initial filter count");
-    FilterStorage.addFilter(Filter.fromText("barfoo"));
-    test.equal([...FilterStorage.subscriptions()][0].filters.length, 2, "Filter count after adding a filter");
-    return FilterStorage.saveToDisk();
+    test.equal([...filterStorage.subscriptions()][0].filters.length, 1, "Initial filter count");
+    filterStorage.addFilter(Filter.fromText("barfoo"));
+    test.equal([...filterStorage.subscriptions()][0].filters.length, 2, "Filter count after adding a filter");
+    return filterStorage.saveToDisk();
   }).then(() =>
   {
-    return FilterStorage.loadFromDisk();
+    return filterStorage.loadFromDisk();
   }).then(() =>
   {
-    test.equal([...FilterStorage.subscriptions()][0].filters.length, 2, "Filter count after adding filter and reloading");
-    return FilterStorage.restoreBackup(1);
+    test.equal([...filterStorage.subscriptions()][0].filters.length, 2, "Filter count after adding filter and reloading");
+    return filterStorage.restoreBackup(1);
   }).then(() =>
   {
-    test.equal([...FilterStorage.subscriptions()][0].filters.length, 1, "Filter count after restoring backup");
-    return FilterStorage.loadFromDisk();
+    test.equal([...filterStorage.subscriptions()][0].filters.length, 1, "Filter count after restoring backup");
+    return filterStorage.loadFromDisk();
   }).then(() =>
   {
-    test.equal([...FilterStorage.subscriptions()][0].filters.length, 1, "Filter count after reloading");
+    test.equal([...filterStorage.subscriptions()][0].filters.length, 1, "Filter count after reloading");
   }).catch(unexpectedError.bind(test)).then(() => test.done());
 };
Index: test/synchronizer.js
===================================================================
--- a/test/synchronizer.js
+++ b/test/synchronizer.js
@@ -18,56 +18,56 @@
 "use strict";
 
 let {
   createSandbox, setupTimerAndXMLHttp, setupRandomResult, unexpectedError, Cr,
   MILLIS_IN_SECOND, MILLIS_IN_HOUR
 } = require("./_common");
 
 let Filter = null;
-let FilterStorage = null;
+let filterStorage = null;
 let Prefs = null;
 let Subscription = null;
 
 exports.setUp = function(callback)
 {
   let globals = Object.assign({}, setupTimerAndXMLHttp.call(this),
     setupRandomResult.call(this));
 
   let sandboxedRequire = createSandbox({globals});
   (
     {Filter} = sandboxedRequire("../lib/filterClasses"),
-    {FilterStorage} = sandboxedRequire("../lib/filterStorage"),
+    {filterStorage} = sandboxedRequire("../lib/filterStorage"),
     {Prefs} = sandboxedRequire("./stub-modules/prefs"),
     {Subscription} = sandboxedRequire("../lib/subscriptionClasses"),
     sandboxedRequire("../lib/synchronizer")
   );
 
   callback();
 };
 
 function resetSubscription(subscription)
 {
-  FilterStorage.updateSubscriptionFilters(subscription, []);
+  filterStorage.updateSubscriptionFilters(subscription, []);
   subscription.lastCheck = subscription.lastDownload =
     subscription.version = subscription.lastSuccess =
     subscription.expires = subscription.softExpiration = 0;
   subscription.title = "";
   subscription.homepage = null;
   subscription.errors = 0;
   subscription.downloadStatus = null;
   subscription.requiredVersion = null;
 }
 
 let initialDelay = 1 / 60;
 
 exports.testOneSubscriptionDownloads = function(test)
 {
   let subscription = Subscription.fromURL("http://example.com/subscription");
-  FilterStorage.addSubscription(subscription);
+  filterStorage.addSubscription(subscription);
 
   let requests = [];
   this.registerHandler("/subscription", metadata =>
   {
     requests.push([this.getTimeOffset(), metadata.method, metadata.path]);
     return [Cr.NS_OK, 200, "[Adblock]\n! ExPiREs: 1day\nfoo\nbar"];
   });
 
@@ -79,23 +79,23 @@
       [48 + initialDelay, "GET", "/subscription"]
     ], "Requests after 50 hours");
   }).catch(unexpectedError.bind(test)).then(() => test.done());
 };
 
 exports.testTwoSubscriptionsDownloads = function(test)
 {
   let subscription1 = Subscription.fromURL("http://example.com/subscription1");
-  FilterStorage.addSubscription(subscription1);
+  filterStorage.addSubscription(subscription1);
 
   let subscription2 = Subscription.fromURL("http://example.com/subscription2");
   subscription2.expires =
     subscription2.softExpiration =
     (this.currentTime + 2 * MILLIS_IN_HOUR) / MILLIS_IN_SECOND;
-  FilterStorage.addSubscription(subscription2);
+  filterStorage.addSubscription(subscription2);
 
   let requests = [];
   let handler = metadata =>
   {
     requests.push([this.getTimeOffset(), metadata.method, metadata.path]);
     return [Cr.NS_OK, 200, "[Adblock]\n! ExPiREs: 1day\nfoo\nbar"];
   };
 
@@ -124,17 +124,17 @@
   {header: "[Adblock Plus 0.0.1]", downloadStatus: "synchronize_ok", requiredVersion: "0.0.1"},
   {header: "[Adblock Plus 99.9]", downloadStatus: "synchronize_ok", requiredVersion: "99.9"},
   {header: "[Foo]", downloadStatus: "synchronize_invalid_data", requiredVersion: null}
 ])
 {
   exports.testSubscriptionHeaders[currentTest.header] = function(test)
   {
     let subscription = Subscription.fromURL("http://example.com/subscription");
-    FilterStorage.addSubscription(subscription);
+    filterStorage.addSubscription(subscription);
 
     this.registerHandler("/subscription", metadata =>
     {
       return [Cr.NS_OK, 200, currentTest.header + "\n!Expires: 8 hours\nfoo\n!bar\n\n@@bas\n#bam"];
     });
 
     this.runScheduledTasks(2).then(() =>
     {
@@ -159,17 +159,17 @@
   };
 }
 
 exports.testsDisabledUpdates = function(test)
 {
   Prefs.subscriptions_autoupdate = false;
 
   let subscription = Subscription.fromURL("http://example.com/subscription");
-  FilterStorage.addSubscription(subscription);
+  filterStorage.addSubscription(subscription);
 
   let requests = 0;
   this.registerHandler("/subscription", metadata =>
   {
     requests++;
     throw new Error("Unexpected request");
   });
 
@@ -248,17 +248,17 @@
   let testId = `"${currentTest.expiration}"`;
   if (currentTest.randomResult != 0.5)
     testId += " with Math.random() returning " + currentTest.randomResult;
   if (currentTest.skip)
     testId += " skipping " + currentTest.skip + " hours after " + currentTest.skipAfter + " hours";
   exports.testExpirationTime[testId] = function(test)
   {
     let subscription = Subscription.fromURL("http://example.com/subscription");
-    FilterStorage.addSubscription(subscription);
+    filterStorage.addSubscription(subscription);
 
     let requests = [];
     this.registerHandler("/subscription", metadata =>
     {
       requests.push(this.getTimeOffset());
       return [Cr.NS_OK, 200, "[Adblock]\n!Expires: " + currentTest.expiration + "\nbar"];
     });
 
@@ -292,17 +292,17 @@
   {
     test.equal(subscription.version, 1234, "Version comment");
   }]
 ])
 {
   exports.testSpecialComments[comment] = function(test)
   {
     let subscription = Subscription.fromURL("http://example.com/subscription");
-    FilterStorage.addSubscription(subscription);
+    filterStorage.addSubscription(subscription);
 
     this.registerHandler("/subscription", metadata =>
     {
       return [Cr.NS_OK, 200, "[Adblock]\n" + comment + "\nfoo\nbar"];
     });
 
     this.runScheduledTasks(2).then(() =>
     {
@@ -310,71 +310,71 @@
       test.deepEqual(subscription.filters, [Filter.fromText("foo"), Filter.fromText("bar")], "Special comment not added to filters");
     }).catch(unexpectedError.bind(test)).then(() => test.done());
   };
 }
 
 exports.testRedirects = function(test)
 {
   let subscription = Subscription.fromURL("http://example.com/subscription");
-  FilterStorage.addSubscription(subscription);
+  filterStorage.addSubscription(subscription);
 
   this.registerHandler("/subscription", metadata =>
   {
     return [Cr.NS_OK, 200, "[Adblock]\n!Redirect: http://example.com/redirected\nbar"];
   });
 
   let requests;
 
   this.runScheduledTasks(30).then(() =>
   {
-    test.equal([...FilterStorage.subscriptions()][0], subscription, "Invalid redirect ignored");
+    test.equal([...filterStorage.subscriptions()][0], subscription, "Invalid redirect ignored");
     test.equal(subscription.downloadStatus, "synchronize_connection_error", "Connection error recorded");
     test.equal(subscription.errors, 2, "Number of download errors");
 
     requests = [];
 
     this.registerHandler("/redirected", metadata =>
     {
       requests.push(this.getTimeOffset());
       return [Cr.NS_OK, 200, "[Adblock]\n! Expires: 8 hours\nbar"];
     });
 
     resetSubscription(subscription);
     return this.runScheduledTasks(15);
   }).then(() =>
   {
-    test.equal([...FilterStorage.subscriptions()][0].url, "http://example.com/redirected", "Redirect followed");
+    test.equal([...filterStorage.subscriptions()][0].url, "http://example.com/redirected", "Redirect followed");
     test.deepEqual(requests, [0 + initialDelay, 8 + initialDelay], "Resulting requests");
 
     this.registerHandler("/redirected", metadata =>
     {
       return [Cr.NS_OK, 200, "[Adblock]\n!Redirect: http://example.com/subscription\nbar"];
     });
 
     subscription = Subscription.fromURL("http://example.com/subscription");
     resetSubscription(subscription);
-    FilterStorage.removeSubscription([...FilterStorage.subscriptions()][0]);
-    FilterStorage.addSubscription(subscription);
+    filterStorage.removeSubscription([...filterStorage.subscriptions()][0]);
+    filterStorage.addSubscription(subscription);
 
     return this.runScheduledTasks(2);
   }).then(() =>
   {
-    test.equal([...FilterStorage.subscriptions()][0], subscription, "Redirect not followed on redirect loop");
+    test.equal([...filterStorage.subscriptions()][0], subscription, "Redirect not followed on redirect loop");
     test.equal(subscription.downloadStatus, "synchronize_connection_error", "Download status after redirect loop");
   }).catch(unexpectedError.bind(test)).then(() => test.done());
 };
 
 exports.testFallback = function(test)
 {
   Prefs.subscriptions_fallbackerrors = 3;
   Prefs.subscriptions_fallbackurl = "http://example.com/fallback?%SUBSCRIPTION%&%CHANNELSTATUS%&%RESPONSESTATUS%";
 
   let subscription = Subscription.fromURL("http://example.com/subscription");
-  FilterStorage.addSubscription(subscription);
+  filterStorage.addSubscription(subscription);
 
   // No valid response from fallback
 
   let requests = [];
   let fallbackParams;
   let redirectedRequests;
   this.registerHandler("/subscription", metadata =>
   {
@@ -402,75 +402,75 @@
   {
     test.deepEqual(requests, [0 + initialDelay, 24 + initialDelay, 48 + initialDelay], "Stop trying if the fallback responds with Gone");
     test.equal(fallbackParams, "http://example.com/subscription&0&404", "Fallback arguments");
 
     // Fallback redirecting to a missing file
 
     subscription = Subscription.fromURL("http://example.com/subscription");
     resetSubscription(subscription);
-    FilterStorage.removeSubscription([...FilterStorage.subscriptions()][0]);
-    FilterStorage.addSubscription(subscription);
+    filterStorage.removeSubscription([...filterStorage.subscriptions()][0]);
+    filterStorage.addSubscription(subscription);
     requests = [];
 
     this.registerHandler("/fallback", metadata =>
     {
       return [Cr.NS_OK, 200, "301 http://example.com/redirected"];
     });
     return this.runScheduledTasks(100);
   }).then(() =>
   {
-    test.equal([...FilterStorage.subscriptions()][0].url, "http://example.com/subscription", "Ignore invalid redirect from fallback");
+    test.equal([...filterStorage.subscriptions()][0].url, "http://example.com/subscription", "Ignore invalid redirect from fallback");
     test.deepEqual(requests, [0 + initialDelay, 24 + initialDelay, 48 + initialDelay, 72 + initialDelay, 96 + initialDelay], "Requests not affected by invalid redirect");
 
     // Fallback redirecting to an existing file
 
     resetSubscription(subscription);
     requests = [];
     redirectedRequests = [];
     this.registerHandler("/redirected", metadata =>
     {
       redirectedRequests.push(this.getTimeOffset());
       return [Cr.NS_OK, 200, "[Adblock]\n!Expires: 1day\nfoo\nbar"];
     });
 
     return this.runScheduledTasks(100);
   }).then(() =>
   {
-    test.equal([...FilterStorage.subscriptions()][0].url, "http://example.com/redirected", "Valid redirect from fallback is followed");
+    test.equal([...filterStorage.subscriptions()][0].url, "http://example.com/redirected", "Valid redirect from fallback is followed");
     test.deepEqual(requests, [0 + initialDelay, 24 + initialDelay, 48 + initialDelay], "Stop polling original URL after a valid redirect from fallback");
     test.deepEqual(redirectedRequests, [48 + initialDelay, 72 + initialDelay, 96 + initialDelay], "Request new URL after a valid redirect from fallback");
 
     // Redirect loop
 
     this.registerHandler("/subscription", metadata =>
     {
       return [Cr.NS_OK, 200, "[Adblock]\n! Redirect: http://example.com/subscription2"];
     });
     this.registerHandler("/subscription2", metadata =>
     {
       return [Cr.NS_OK, 200, "[Adblock]\n! Redirect: http://example.com/subscription"];
     });
 
     subscription = Subscription.fromURL("http://example.com/subscription");
     resetSubscription(subscription);
-    FilterStorage.removeSubscription([...FilterStorage.subscriptions()][0]);
-    FilterStorage.addSubscription(subscription);
+    filterStorage.removeSubscription([...filterStorage.subscriptions()][0]);
+    filterStorage.addSubscription(subscription);
 
     return this.runScheduledTasks(100);
   }).then(() =>
   {
-    test.equal([...FilterStorage.subscriptions()][0].url, "http://example.com/redirected", "Fallback can still redirect even after a redirect loop");
+    test.equal([...filterStorage.subscriptions()][0].url, "http://example.com/redirected", "Fallback can still redirect even after a redirect loop");
   }).catch(unexpectedError.bind(test)).then(() => test.done());
 };
 
 exports.testStateFields = function(test)
 {
   let subscription = Subscription.fromURL("http://example.com/subscription");
-  FilterStorage.addSubscription(subscription);
+  filterStorage.addSubscription(subscription);
 
   this.registerHandler("/subscription", metadata =>
   {
     return [Cr.NS_OK, 200, "[Adblock]\n! Expires: 2 hours\nfoo\nbar"];
   });
 
   let startTime = this.currentTime;
   this.runScheduledTasks(2).then(() =>