WIP: Have one global element hide stylesheet and inject the other ones per site

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 48 matching lines @@
  * @type nsIURI
  */
 let styleURL = null;
 
 /**
  * Global stylesheet that should be loaded into content windows.
  * @type nsIStyleSheet
  */
 let styleSheet = null;
 
-// fixme
-let filterByDomain = Object.create(null);
-
-/**
- * Use new way of injecting styles per Window that exists since Firefox 33.
+/**
+ * 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 =
 {
@@ skipping 53 matching lines @@
   {
     if (topic != "content-document-global-created")
       return;
 
     if (!Prefs.enabled)
       return;
 
     if (Policy.shouldNeverBlockWindow(subject))
       return;
 
-    dump(subject.document.documentURIObject.spec + "\n");
-    let domain = subject.document.documentURIObject.host;
-    if (domain.startsWith("www."))
-      domain = domain.substring(4);
-
-    dump("domain: " + domain + "\n"); // xxx is elemhide port or subdomain insesitive?
-
-    let list = Object.create(null);
-    for (let filter of filterByDomain[domain])
-    {
-      dump("filter: " + filter.text + "\n")
-      dump("key:  " +  keyByFilter[filter.text] + "\n")
-      list[keyByFilter[filter.text]] = filter;
-    }
-
-    if (filterByDomain[domain]) {
-      // XXX seems to stupid to use a file for this.
-      // Somehow get this to use a data url or similar
-      let styleFile = IO.resolveFilePath(Prefs.data_directory);
-      styleFile.append(domain + ".css");
-      styleURL = Services.io.newFileURI(styleFile).QueryInterface(Ci.nsIFileURL);
-
-      IO.writeToFile(styleURL.file, this._generateCSSContent(list, false), function(e)
-      {
-        try
-        {
-          let utils = subject.QueryInterface(Ci.nsIInterfaceRequestor)
-                             .getInterface(Ci.nsIDOMWindowUtils);
-          utils.loadSheet(styleURL, Ci.nsIStyleSheetService.USER_SHEET);
-        }
-        catch (e)
-        {
-          Cu.reportError(e);
-        }
-      });
-    }
-
-    try
-    {
-      let utils = subject.QueryInterface(Ci.nsIInterfaceRequestor)
-                         .getInterface(Ci.nsIDOMWindowUtils);
-      utils.addSheet(styleSheet, Ci.nsIStyleSheetService.USER_SHEET);
-    }
-    catch (e)
-    {
-      Cu.reportError(e);
+    let domain = null;
+    let filters = null;
+     try
+     {
+      domain = subject.document.documentURIObject.host;
+      if (domain)
+        filters = ElemHide.getFiltersWithKeyForDomain(domain, true);
+    } catch (e) {}
+
+    if (filters)
+    {
+      let list = Object.create(null);
+      for (let {key, filter} of filters)
+        list[key] = filter;
+
+      let css = "";
+      for (let line in this._generateCSSContent(list, false))
+        css += line + "\n";
+
+      let uri = Services.io.newURI("data:text/css;base64," + btoa(css), null, null);
+      try
+      {
+        let utils = subject.QueryInterface(Ci.nsIInterfaceRequestor)
+                           .getInterface(Ci.nsIDOMWindowUtils);
+        utils.loadSheet(uri, Ci.nsIStyleSheetService.USER_SHEET);
+      }
+      catch (e)
+      {
+        Cu.reportError(e);
+      }
+    }
+
+    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);
-    filterByDomain = Object.create(null);
     ElemHide.isDirty = false;
     ElemHide.unapply();
   },
 
   /**
    * Add a new element hiding filter
    * @param {ElemHideFilter} filter
    */
   add: function(filter)
   {
     if (filter instanceof ElemHideException)
     {
       if (filter.text in knownExceptions)
         return;
 
       let selector = filter.selector;
       if (!(selector in exceptions))
         exceptions[selector] = [];
       exceptions[selector].push(filter);
       knownExceptions[filter.text] = true;
     }
     else
     {
       if (filter.text in keyByFilter)
         return;
 
-      if (filter.selectorDomain && useNew)
-      {
-        let domains = filter.selectorDomain.split(",");
-
-        for (let domain of domains)
-        {
-          dump(domain + "\n");
-          if (filterByDomain[domain])
-            filterByDomain[domain].push(filter);
-          else
-            filterByDomain[domain] = [filter];
-        }
-      }
-
       let key;
       do {
         key = Math.random().toFixed(15).substr(5);
       } while (key in filterByKey);
 
       filterByKey[key] = filter;
       keyByFilter[filter.text] = key;
       ElemHide.isDirty = true;
     }
   },
@@ skipping 13 matching lines @@
       let index = list.indexOf(filter);
       if (index >= 0)
         list.splice(index, 1);
       delete knownExceptions[filter.text];
     }
     else
     {
       if (!(filter.text in keyByFilter))
         return;
 
-      // if (filter.selectorDomain && useNew)
-      // {
-      //   let filters = filterByDomain[filter.selectorDomain];
-      //   if (Array.isArray(filters))
-      //     filters.splice(filters.indexOf(filter), 1);
-      //   else
-      //     delete filterByDomain[filter.selectorDomain];
-      // }
-
       let key = keyByFilter[filter.text];
       delete filterByKey[key];
       delete keyByFilter[filter.text];
       ElemHide.isDirty = true;
     }
   },
 
-  /** 
+  /**
    * Checks whether an exception rule is registered for a filter on a particular
    * domain.
    */
   getException: function(/**Filter*/ filter, /**String*/ docDomain) /**ElemHideException*/
   {
-    let selector = filter.selector;
     if (!(filter.selector in exceptions))
       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;
   },
@@ skipping 77 matching lines @@
       {
         ElemHide.isDirty = false;
 
         ElemHide.unapply();
         TimeLine.log("ElemHide.unapply() finished");
 
         if (!noFilters)
         {
           try
           {
-            if (!useNew) {
+            if (!useNew)
               Utils.styleService.loadAndRegisterSheet(styleURL, Ci.nsIStyleSheetService.USER_SHEET);
-            } else {
+            else
               styleSheet = Utils.styleService.preloadSheet(styleURL, Ci.nsIStyleSheetService.USER_SHEET);
-            }
             ElemHide.applied = true;
           }
           catch (e)
           {
             Cu.reportError(e);
           }
           TimeLine.log("Applying stylesheet finished");
+          Cu.reportError("applying finished");
         }
 
         FilterNotifier.triggerListeners("elemhideupdate");
       }
       TimeLine.leave("ElemHide.apply() write callback done");
     }.bind(this), "ElemHideWrite");
 
     this._applying = true;
 
     TimeLine.leave("ElemHide.apply() done", "ElemHideWrite");
@@ skipping 101 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;
+  },
+
+  getFiltersWithKeyForDomain: function(/**String*/ domain)
+  {
+    let result = [];
+    for (let key in filterByKey)
+    {
+      let filter = filterByKey[key];
+
+      if (!filter.domains)
+        continue
+
+      if (filter.isActiveOnDomain(domain) && !this.getException(filter, domain))
+        result.push({key, filter});
+    }
+    return result;
   }
+
 };