Added handling of whitelisting rules like @@||example.com^$document

lib/matcher.js

 /*
  * This file is part of the Adblock Plus extension,
  * Copyright (C) 2006-2012 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 12 matching lines @@
 (function()
 {
   // Make sure that filters don't apply to extension pages. We shouldn't allow
   // users to break our options page unintentionally, recovering is very hard
   // if they do.
   opera.extension.urlfilter.allow.add("widget://*");
 
   var WhitelistFilter = null;
   var RegExpFilter = null;
   var resourceTypes = [
-      "DOCUMENT", "FONT", "IMAGE", "MEDIA", "OBJECT", "OBJECT_SUBREQUEST",
+      "FONT", "IMAGE", "MEDIA", "OBJECT", "OBJECT_SUBREQUEST",
       "OTHER", "SCRIPT", "STYLESHEET", "SUBDOCUMENT", "XMLHTTPREQUEST"
   ];
 
   require.scopes.matcher =
   {
     defaultMatcher:
     {
       _rules: {},
+      _domainExceptions: {},
+      _domainExceptionsTimeout: null,
 
       /**
        * Converts rule text from Adblock Plus format (implicit * at beginning
        * and end of the rule unless there is an anchor) to Opera format (* has
        * to be specified explicitly).
        */
       _getRuleText: function(/**Filter*/ filter) /**String*/
       {
         var text = filter.regexpSource;
 
@@ skipping 80 matching lines @@
       /**
        * Converts an Adblock Plus filter to a rule that can be processed by
        * Opera. The following options will be set:
        *
        *  type: urlfilter to be used, either "allow" or "block"
        *  text: rule text
        *  options: rule options
        */
       _generateRule: function(/**Filter*/ filter) /**Object*/
       {
-        if (!WhitelistFilter)
-        {
-          WhitelistFilter = require("filterClasses").WhitelistFilter;
-          RegExpFilter = require("filterClasses").RegExpFilter;
-        }
-
         var rule = {
           type: filter instanceof WhitelistFilter ? "allow" : "block",
           text: this._getRuleText(filter),
           options: {
             resources: this._getRuleTypes(filter)
           }
         };
         this._getRuleDomains(filter, rule.options);
         this._getRuleThirdParty(filter, rule.options);
         return rule;
       },
 
+      /**
+       * Extracts the domain to which the exception applies if any.
+       */
+      _getDomainFromException: function(/**Filter*/ filter) /**String*/
+      {
+        if (filter.domainSource)
+          return null;
+
+        var match = /^\|\|([^\/]+)\^$/.exec(filter.regexpSource);
+        if (!match)
+          return null;
+
+        return match[1];
+      },
+
+      /**
+       * Adds a global exception for a particular document domain.
+       */
+      _addDomainException: function(/**String*/ domain)
+      {
+        this._domainExceptions[domain] = true;
+
+        // Update domain exceptions rule delayed to prevent multiple subsequent
+        // updates.
+        if (this._domainExceptionsTimeout)
+          window.clearTimeout(this._domainExceptionsTimeout);
+        this._domainExceptionsTimeout = window.setTimeout(this._updateDomainExceptions.bind(this), 0);
+      },
+
+      /**
+       * Removes a global exception for a particular document domain.
+       */
+      _removeDomainException: function(/**String*/ domain)
+      {
+        delete this._domainExceptions[domain];
+
+        // Update domain exceptions rule delayed to prevent multiple subsequent
+        // updates.
+        if (this._domainExceptionsTimeout)
+          window.clearTimeout(this._domainExceptionsTimeout);
+        this._domainExceptionsTimeout = window.setTimeout(this._updateDomainExceptions.bind(this), 0);
+      },
+
+      /**
+       * Updates domain exceptions rule (should be called delayed).
+       */
+      _updateDomainExceptions: function()
+      {
+        this._domainExceptionsTimeout = null;
+        opera.extension.urlfilter.allow.remove("*:*");
+
+        var domains = Object.keys(this._domainExceptions);
+        if (domains.length)
+        {
+          opera.extension.urlfilter.allow.add("*:*", {
+            includeDomains: domains
+          });
+        }
+      },
+
       add: function(filter)
       {
+        if (!WhitelistFilter)

[Felix Dahlke, 2012/11/14 13:03:51]

Not a new problem, but can't we do this earlier? Both remove and _generateRule
rely on add being executed first. (Arguably less of a problem with
_generateRule, since it's only invoked from add.)

[Wladimir Palant, 2012/11/14 13:46:53]

Yes, it's ugly. Problem is that matcher.js needs to be included before
background.js - meaning that it cannot just require() its dependencies while
loading. Let's try a different hack...

+        {
+          WhitelistFilter = require("filterClasses").WhitelistFilter;
+          RegExpFilter = require("filterClasses").RegExpFilter;
+        }
+
+        if (filter instanceof WhitelistFilter && filter.contentType == RegExpFilter.typeMap.DOCUMENT)

[Felix Dahlke, 2012/11/14 13:03:51]

I'd like a function for both this check and the _getDomainFromException call
below, since we have the same code in remove.

Maybe something like this:

var whitelistedDomain = this._getWhitelistedDomain(filter);
if (whitelistedDomain)
  this._addDomainException(whitelistedDomain); // or remove, respectively

[Wladimir Palant, 2012/11/14 13:46:53]

Ok, I changed the solution to have maximal code reuse.

+        {
+          var domain = this._getDomainFromException(filter);
+          if (domain)
+            this._addDomainException(domain);
+        }
+
         if (filter.text in this._rules)
           return;
 
         if (!filter.regexpSource) // Regular expressions aren't supported
           return;
 
         var rule = this._generateRule(filter);
         opera.extension.urlfilter[rule.type].add(rule.text, rule.options);
         this._rules[filter.text] = rule;
       },
 
       remove: function(filter)
       {
+        if (filter instanceof WhitelistFilter && filter.contentType == RegExpFilter.typeMap.DOCUMENT)
+        {
+          var domain = this._getDomainFromException(filter);
+          if (domain)
+            this._removeDomainException(domain);
+        }
+
         if (!(filter.text in this._rules))
           return;
 
         var rule = this._rules[filter.text];
         opera.extension.urlfilter[rule.type].remove(rule.text);
         delete this._rules[filter.text];
       },
 
       clear: function()
       {
         for (var text in this._rules)
         {
           var rule = this._rules[text];
           opera.extension.urlfilter[rule.type].remove(rule.text);
         }
         this._rules = {};
+
+        for (var domain in this._domainExceptions)
+          this._removeDomainException(domain);
+        this._domainExceptions = {};
       }
     }
   };
 })();