Issue 521- Inject our stylesheet on per-site basis rather than globally

lib/elemHide.js

 /*
  * This file is part of Adblock Plus <http://adblockplus.org/>,
  * Copyright (C) 2006-2014 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 10 matching lines @@
 
 Cu.import("resource://gre/modules/Services.jsm");
 
 let {Utils} = require("utils");
 let {IO} = require("io");
 let {Prefs} = require("prefs");
 let {ElemHideException} = require("filterClasses");
 let {FilterNotifier} = require("filterNotifier");
 let {AboutHandler} = require("elemHideHitRegistration");
 let {TimeLine} = require("timeline");
+let Policy = null;
 
 /**
  * Lookup table, filters by their associated key
  * @type Object
  */
-let filterByKey = {__proto__: null};
+let filterByKey = Object.create(null);
 
 /**
  * Lookup table, keys of the filters by filter text
  * @type Object
  */
-let keyByFilter = {__proto__: null};
+let keyByFilter = Object.create(null);
 
 /**
  * Lookup table, keys are known element hiding exceptions
  * @type Object
  */
-let knownExceptions = {__proto__: null};
+let knownExceptions = Object.create(null);
 
 /**
  * Lookup table, lists of element hiding exceptions by selector
  * @type Object
  */
-let exceptions = {__proto__: null};
+let exceptions = Object.create(null);
 
 /**
  * Currently applied stylesheet URL
  * @type nsIURI
  */
 let styleURL = null;
 
 /**
+ * Global stylesheet that should be loaded into content windows.
+ * @type nsIStyleSheet
+ */
+let styleSheet = null;
+
+/**
+ * Use the new way of injecting styles per window that exists since Firefox 33.
+ * @type boolean
+ */
+let useNew = ('preloadSheet' in Utils.styleService);
+
+/**
  * Element hiding component
  * @class
  */
 let ElemHide = exports.ElemHide =
 {
+  QueryInterface: XPCOMUtils.generateQI([Ci.nsIObserver, Ci.nsISupportsWeakReference]),
+
   /**
    * Indicates whether filters have been added or removed since the last apply() call.
    * @type Boolean
    */
   isDirty: false,
 
-  QueryInterface: XPCOMUtils.generateQI([Ci.nsIObserver, Ci.nsISupportsWeakReference]),
+  /**
+   * Inidicates whether the element hiding stylesheet is currently applied.
+   * @type Boolean
+   */
+  applied: false,
 
   /**
    * Called on module startup.
    */
   init: function()
   {
     TimeLine.enter("Entered ElemHide.init()");
+
+    if (useNew) {
+      // Avoid dependency issue.
+      Policy = require("contentPolicy").Policy;
+    }
+
     Prefs.addListener(function(name)
     {
       if (name == "enabled")
         ElemHide.apply();
     });

[Wladimir Palant, 2014/05/20 19:36:12]

This code is no longer necessary.

-    onShutdown.add(function()
-    {
-      Services.obs.removeObserver(this, "content-document-global-created");
-    }.bind(this));
+
+    if (useNew)
+      Services.obs.addObserver(this, "content-document-global-created", true);
+
+    onShutdown.add(() =>
+    {
+      ElemHide.unapply();
+      if (useNew)
+        Services.obs.removeObserver(this, "content-document-global-created");
+    });
 
     TimeLine.log("done adding prefs listener");
 
     let styleFile = IO.resolveFilePath(Prefs.data_directory);
     styleFile.append("elemhide.css");
     styleURL = Services.io.newFileURI(styleFile).QueryInterface(Ci.nsIFileURL);
     TimeLine.log("done determining stylesheet URL");
 
-    Services.obs.addObserver(this, "content-document-global-created", true);
-
     TimeLine.leave("ElemHide.init() done");
-  },
-
-  /**
-   * Removes all known filters
-   */
-  clear: function()
-  {
-    filterByKey = {__proto__: null};
-    keyByFilter = {__proto__: null};
-    knownExceptions = {__proto__: null};
-    exceptions = {__proto__: null};
-    ElemHide.isDirty = false;
   },
 
   observe: function (subject, topic, data, additional)
   {
     if (topic != "content-document-global-created")
       return;
 
     if (!Prefs.enabled)
       return;
 
-    let uri = subject.document.documentURIObject;
-    if (!uri)
+    if (Policy.shouldNeverBlockWindow(subject))
       return;
 
-    switch(uri.scheme)
-    {
-      case "http":
-      case "https":
-      case "mailbox":
-      case "imap":
-      case "news":
-      case "snews":
-        break;
-      default:
-        // Avoid injecting in chrome documents
-        return;
-    }

[Wladimir Palant, 2014/05/20 19:36:12]

Please use Policy.isBlockableScheme() here (from contentPolicy.js).

-
-    // XXX is there some better way to test if it's disabled on that domain that we should do before?
-    if (!ElemHide.anySelectorForDomain(uri.host))
-      return;

[Wladimir Palant, 2014/05/20 19:36:12]

Wow, performance will go down the drain here. We can simply assume that there
are always *some* filters applying - as long as element hiding isn't generally
disabled.

Currently this check is being performed in Policy.processNode() (called from
elemHideHitRegistration.js). We need to move this logic into a separate
function, it will now be called both from Policy.processNode() and from here.
For the window and each of its parents, check whether the scheme is blockable at
all, whether any exception rule for type DOCUMENT or type ELEMHIDE exists for
that URL, plus sitekey-based exceptions.

The logic in elemHideHitRegistration.js should be simplified then. Rather than
going through the full Policy.processNode() processing, it should merely check
whether any element hiding exceptions apply and register a hit.

-
-    var windowUtils = subject.QueryInterface(Ci.nsIInterfaceRequestor).getInterface(Ci.nsIDOMWindowUtils);
-    windowUtils.loadSheet(styleURL, Ci.nsIStyleSheetService.USER_SHEET);
+    if (styleSheet)
+    {
+      try
+      {
+        let utils = subject.QueryInterface(Ci.nsIInterfaceRequestor)
+                           .getInterface(Ci.nsIDOMWindowUtils);
+        utils.addSheet(styleSheet, Ci.nsIStyleSheetService.USER_SHEET);
+      }
+      catch (e)
+      {
+        Cu.reportError(e);
+      }
+    }
+   },
+
+  /**
+   * Removes all known filters
+   */
+  clear: function()
+  {
+    filterByKey = Object.create(null);
+    keyByFilter = Object.create(null);
+    knownExceptions = Object.create(null);
+    exceptions = Object.create(null);
+    ElemHide.isDirty = false;
+    ElemHide.unapply();
   },
 
   /**
    * Add a new element hiding filter
    * @param {ElemHideFilter} filter
    */
   add: function(filter)
   {
     if (filter instanceof ElemHideException)
     {
@@ skipping 76 matching lines @@
   _applying: false,
 
   /**
    * Will be set to true if an apply() call arrives while apply() is already
    * running (delayed execution).
    * @type Boolean
    */
   _needsApply: false,
 
   /**
-   * Generates stylesheet URL.
-   */
-  // XXX Rename
+   * Generates stylesheet URL and applies it globally
+   */
   apply: function()

[Wladimir Palant, 2014/05/20 19:36:12]

saveStylesheet()?

   {
     if (this._applying)
     {
       this._needsApply = true;
       return;
     }
 
     TimeLine.enter("Entered ElemHide.apply()");
+
+    if (!ElemHide.isDirty || !Prefs.enabled)
+    {
+      // Nothing changed, looks like we merely got enabled/disabled
+      if (Prefs.enabled && !ElemHide.applied)
+      {
+        try
+        {
+          if (!useNew)
+            Utils.styleService.loadAndRegisterSheet(styleURL, Ci.nsIStyleSheetService.USER_SHEET);
+          ElemHide.applied = true;
+        }
+        catch (e)
+        {
+          Cu.reportError(e);
+        }
+        TimeLine.log("Applying existing stylesheet finished");
+      }
+      else if (!Prefs.enabled && ElemHide.applied)
+      {
+        ElemHide.unapply();
+        TimeLine.log("ElemHide.unapply() finished");
+      }
+
+      TimeLine.leave("ElemHide.apply() done (no file changes)");
+      return;
+    }
 
     IO.writeToFile(styleURL.file, this._generateCSSContent(), function(e)
     {
       TimeLine.enter("ElemHide.apply() write callback");
       this._applying = false;
 
       // _generateCSSContent is throwing NS_ERROR_NOT_AVAILABLE to indicate that
       // there are no filters. If that exception is passed through XPCOM we will
       // see a proper exception here, otherwise a number.
       let noFilters = (e == Cr.NS_ERROR_NOT_AVAILABLE || (e && e.result == Cr.NS_ERROR_NOT_AVAILABLE));
       if (noFilters)
       {
         e = null;
         IO.removeFile(styleURL.file, function(e) {});
       }
       else if (e)
         Cu.reportError(e);
 
       if (this._needsApply)
       {
         this._needsApply = false;
         this.apply();
       }
       else if (!e)
       {
         ElemHide.isDirty = false;
 
+        ElemHide.unapply();
+        TimeLine.log("ElemHide.unapply() finished");
+
+        if (!noFilters)
+        {
+          try
+          {
+            if (!useNew)
+              Utils.styleService.loadAndRegisterSheet(styleURL, Ci.nsIStyleSheetService.USER_SHEET);
+            else
+              styleSheet = Utils.styleService.preloadSheet(styleURL, Ci.nsIStyleSheetService.USER_SHEET);
+            ElemHide.applied = true;
+          }
+          catch (e)
+          {
+            Cu.reportError(e);
+          }
+          TimeLine.log("Applying stylesheet finished");
+        }
+
         FilterNotifier.triggerListeners("elemhideupdate");

[Wladimir Palant, 2014/05/20 19:36:12]

Apparently, this is dead code. This notification has been introduced in
https://hg.adblockplus.org/adblockplus/rev/1c10d9bd251d and is no longer used
anywhere - the e10s support is no more. Feel free to remove it while at it.

       }
       TimeLine.leave("ElemHide.apply() write callback done");
     }.bind(this), "ElemHideWrite");
 
     this._applying = true;
 
     TimeLine.leave("ElemHide.apply() done", "ElemHideWrite");
   },
 
   _generateCSSContent: function()
   {
     // Grouping selectors by domains
     TimeLine.log("start grouping selectors");
-    let domains = {__proto__: null};
+    let domains = Object.create(null);
     let hasFilters = false;
     for (let key in filterByKey)
     {
       let filter = filterByKey[key];
       let domain = filter.selectorDomain || "";
 
       let list;
       if (domain in domains)
         list = domains[domain];
       else
       {
-        list = {__proto__: null};
+        list = Object.create(null);
         domains[domain] = list;
       }
       list[filter.selector] = key;
       hasFilters = true;
     }
     TimeLine.log("done grouping selectors");
 
     if (!hasFilters)
       throw Cr.NS_ERROR_NOT_AVAILABLE;
 
@@ skipping 23 matching lines @@
         yield selector.replace(/[^\x01-\x7F]/g, escapeChar) + "{" + cssTemplate.replace("%ID%", list[selector]) + "}";
       yield '}';
     }
   },
 
   /**
    * Unapplies current stylesheet URL
    */
   unapply: function()
   {
-  },

[Wladimir Palant, 2014/05/20 19:36:12]

This function should be removed.

-
-  /**
-   * Retrieves the currently applied stylesheet URL
-   * @type String
-   */
-  get styleURL() styleURL.spec,

[Wladimir Palant, 2014/05/20 19:36:12]

This getter was also introduced in
https://hg.adblockplus.org/adblockplus/rev/1c10d9bd251d and is no longer being
used either, feel free to remove it.

+    if (ElemHide.applied)
+    {
+      try
+      {
+        if (!useNew)
+          Utils.styleService.unregisterSheet(styleURL, Ci.nsIStyleSheetService.USER_SHEET);
+      }
+      catch (e)
+      {
+        Cu.reportError(e);
+      }
+      ElemHide.applied = false;
+    }
+  },
 
   /**
    * Retrieves an element hiding filter by the corresponding protocol key
    */
   getFilterByKey: function(/**String*/ key) /**Filter*/
   {
     return (key in filterByKey ? filterByKey[key] : null);
   },
 
   /**
@@ skipping 12 matching lines @@
       // workaround WebKit bug 132872, also see #419
       let domains = filter.domains;
 
       if (specificOnly && (!domains || domains[""]))
         continue;
 
       if (filter.isActiveOnDomain(domain) && !this.getException(filter, domain))
         result.push(filter.selector);
     }
     return result;
-  },
-
-  anySelectorForDomain: function(/**String*/ domain)
-  {
-    for (let key in filterByKey)
-    {
-      let filter = filterByKey[key];
-
-      if (filter.isActiveOnDomain(domain) && !this.getException(filter, domain))
-        return true;
-    }
-
-    return false;
   }
 };