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
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 /**
  * @fileOverview Element hiding implementation.
  */
 
 Cu.import("resource://gre/modules/Services.jsm");
 
 let {Utils} = require("utils");
 let {IO} = require("io");
 let {Prefs} = require("prefs");
-let {Policy} = require("contentPolicy");
 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 =
 {
-  /**
-   * Indicates whether filters have been added or removed since the last saveStylesheet() call.
+  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()");
 
-    onShutdown.add(function()
-    {
-      Services.obs.removeObserver(this, "content-document-global-created");
-    }.bind(this));
+    if (useNew) {
+      // Avoid dependency issue.
+      Policy = require("contentPolicy").Policy;
+    }
+
+    Prefs.addListener(function(name)
+    {
+      if (name == "enabled")
+        ElemHide.apply();
+    });
+
+    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 process = Policy.processWindow(subject, Policy.type.ELEMHIDE);
-    dump(subject.document.documentURIObject.spec + " is okay " +  process + "\n");
-    if (process)
+    if (Policy.shouldNeverBlockWindow(subject))
       return;
 
-    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 62 matching lines @@
       return null;
 
     let list = exceptions[filter.selector];
     for (let i = list.length - 1; i >= 0; i--)
       if (list[i].isActiveOnDomain(docDomain))
         return list[i];
 
     return null;
   },
 
-  shouldAllowLoad: function(wnd, filter)
-  {
-    let uri = wnd.document.documentURIObject;
-    if (!uri)
-      return true;
-
-    let domain = uri.host;
-    if (!filter.isActiveOnDomain(domain))
-      return true;
-
-    let exception = ElemHide.getException(filter, domain);
-    if (exception)
-    {
-      // FilterStorage.increaseHitCount(exception, wnd);
-      // RequestNotifier.addNodeData(node, topWnd, contentType, domain, thirdParty, locationText, exception);
-      return true;
-    }
-
-    // RequestNotifier.addNodeData(node, topWnd, contentType, domain, thirdParty, locationText, match);
-    // if (match)
-    //   FilterStorage.increaseHitCount(match, wnd);
-    return false;
-  },
-
-  /**
-   * Will be set to true if saveStylesheet() is running (reentrance protection).
+  /**
+   * Will be set to true if apply() is running (reentrance protection).
    * @type Boolean
    */
   _applying: false,
 
   /**
-   * Will be set to true if an saveStylesheet() call arrives while saveStylesheet()
-   * is already running (delayed execution).
+   * Will be set to true if an apply() call arrives while apply() is already
+   * running (delayed execution).
    * @type Boolean
    */
   _needsApply: false,
 
   /**
-   * Generates stylesheet URL.
-   */
-  saveStylesheet: function()
+   * Generates stylesheet URL and applies it globally
+   */
+  apply: function()
   {
     if (this._applying)
     {
       this._needsApply = true;
       return;
     }
 
-    TimeLine.enter("Entered ElemHide.saveStylesheet()");
+    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.saveStylesheet() write callback");
+      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.saveStylesheet();
+        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");
       }
-      TimeLine.leave("ElemHide.saveStylesheet() write callback done");
+      TimeLine.leave("ElemHide.apply() write callback done");
     }.bind(this), "ElemHideWrite");
 
     this._applying = true;
 
-    TimeLine.leave("ElemHide.saveStylesheet() done", "ElemHideWrite");
+    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 19 matching lines @@
                   + 'url-prefix("news://"),url-prefix("snews://"){';
       }
 
       for (let selector in list)
         yield selector.replace(/[^\x01-\x7F]/g, escapeChar) + "{" + cssTemplate.replace("%ID%", list[selector]) + "}";
       yield '}';
     }
   },
 
   /**
+   * Unapplies current stylesheet URL
+   */
+  unapply: function()
+  {
+    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);
   },
 
   /**
    * Returns a list of all selectors active on a particular domain (currently
    * used only in Chrome, Opera and Safari).
@@ skipping 12 matching lines @@
 
       if (specificOnly && (!domains || domains[""]))
         continue;
 
       if (filter.isActiveOnDomain(domain) && !this.getException(filter, domain))
         result.push(filter.selector);
     }
     return result;
   }
 };