Added abstraction for frames, to fix domain-based rules, whitelisting and ad counter on Safari

safari/ext/background.js

 /*
  * This file is part of Adblock Plus <http://adblockplus.org/>,
  * Copyright (C) 2006-2013 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/>.
  */
 
 (function()
 {
-  /* Tabs */
+  /* Events */
 
   var TabEventTarget = function()
   {
     WrappedEventTarget.apply(this, arguments);
   };
   TabEventTarget.prototype = {
     __proto__: WrappedEventTarget.prototype,
     _wrapListener: function(listener)
     {
       return function(event)
@@ skipping 13 matching lines @@
     _wrapListener: function(listener)
     {
       return function (event)
       {
         if (event.name == "loading")
           listener(new Tab(event.target));
       };
     }
   };
 
+  var BackgroundMessageEventTarget = function()
+  {
+    MessageEventTarget.call(this, safari.application);
+  };
+  BackgroundMessageEventTarget.prototype = {
+    __proto__: MessageEventTarget.prototype,
+    _getResponseDispatcher: function(event)
+    {
+      return event.target.page;
+    },
+    _getSenderDetails: function(event)
+    {
+      return {
+        tab: new Tab(event.target),
+        frame: new Frame(
+          event.message.documentUrl,
+          event.message.isTopLevel,
+          event.target
+        )
+      };
+    }
+  };
+
+
+  /* Tabs */
+
   Tab = function(tab)
   {
     this._tab = tab;
 
-    this._eventTarget = tab;
-    this._messageDispatcher = tab.page;
-
     this.browserAction = new BrowserAction(this);
 
     this.onLoading = new LoadingTabEventTarget(tab);
+    this.onBeforeNavigate = new TabEventTarget(tab, "beforeNavigate", false);
     this.onCompleted = new TabEventTarget(tab, "navigate", false);
     this.onActivated = new TabEventTarget(tab, "activate", false);
     this.onRemoved = new TabEventTarget(tab, "close", false);
   };
   Tab.prototype = {
     get url()
     {
       return this._tab.url;
     },
     close: function()
     {
       this._tab.close();
     },
     activate: function()
     {
       this._tab.activate();
     },
-    sendMessage: sendMessage
+    sendMessage: function(message, responseCallback)
+    {
+      _sendMessage(
+        message, responseCallback,
+        this._tab.page, this._tab
+      );
+    }
   };
 
-  TabMap = function()
+  TabMap = function(deleteTabOnBeforeNavigate)
   {
     this._tabs = [];
     this._values = [];
 
-    this._onClosed = this._onClosed.bind(this);
+    this._deleteOnEvent = this._deleteOnEvent.bind(this);
+    this._deleteTabOnBeforeNavigate = deleteTabOnBeforeNavigate;
   };
   TabMap.prototype =
   {
     get: function(tab) {
       var idx;
 
       if (!tab || (idx = this._tabs.indexOf(tab._tab)) == -1)
         return null;
 
       return this._values[idx];
     },
     set: function(tab, value)
     {
       var idx = this._tabs.indexOf(tab._tab);
 
       if (idx != -1)
         this._values[idx] = value;
       else
       {
         this._tabs.push(tab._tab);
         this._values.push(value);
 
-        tab._tab.addEventListener("close", this._onClosed, false);
+        tab._tab.addEventListener("close", this._deleteOnEvent, false);
+        if (this._deleteTabOnBeforeNavigate)
+          tab._tab.addEventListener("beforeNavigate", this._deleteOnEvent, false);
       }
     },
     has: function(tab)
     {
       return this._tabs.indexOf(tab._tab) != -1;
     },
     clear: function()
     {
       while (this._tabs.length > 0)
         this._delete(this._tabs[0]);
     },
     _delete: function(tab)
     {
       var idx = this._tabs.indexOf(tab);
 
       if (idx != -1)
       {
         this._tabs.splice(idx, 1);
         this._values.splice(idx, 1);
 
-        tab.removeEventListener("close", this._onClosed, false);
+        tab.removeEventListener("close", this._deleteOnEvent, false);
+        tab.removeEventListener("beforeNavigate", this._deleteOnEvent, false);
       }
     },
-    _onClosed: function(event)
+    _deleteOnEvent: function(event)
     {
-      this._delete(event.target);
+      // delay so that other event handlers can still look this tab up
+      setTimeout(this._delete.bind(this, event.target), 0);
     }
   };
   TabMap.prototype["delete"] = function(tab)
   {
     this._delete(tab._tab);
   };
 
   ext.tabs = {
     onLoading: new LoadingTabEventTarget(safari.application),
+    onBeforeNavigate: new TabEventTarget(safari.application, "beforeNavigate", true),
     onCompleted: new TabEventTarget(safari.application, "navigate", true),
     onActivated: new TabEventTarget(safari.application, "activate", true),
     onRemoved: new TabEventTarget(safari.application, "close", true)
   };
 
 
   /* Browser actions */
 
   var toolbarItemProperties = {};
 
@@ skipping 103 matching lines @@
     {
       var tab = this._win.openTab();
       tab.url = url;
 
       if (callback)
         callback(new Tab(tab));
     }
   };
 
 
+  /* Frames */
+
+  Frame = function(url, isTopLevel, tab)
+  {
+    this.url = url;
+
+    // there is no way to discover frames with Safari's API.
+    // so if this isn't the top level frame, assume that the parent is.
+    // this is the best we can do for Safari. :(
+    if (!isTopLevel)
+      this.parent = new Frame(tab.url, true);
+    else
+      this.parent = null;
+  };
+
+
   /* Background page proxy */
 
   var proxy = {
     tabs: [],
     objects: [],
 
     registerObject: function(obj, objects)
     {
       var objectId = objects.indexOf(obj);
 
@@ skipping 210 matching lines @@
       }
     }
   };
 
 
   /* Web request blocking */
 
   ext.webRequest = {
     onBeforeRequest: {
       _listeners: [],
-      _urlPatterns: [],
 
-      _handleMessage: function(message, tab)
+      _handleMessage: function(message, rawTab)
       {
-        tab = new Tab(tab);
+        var tab = new Tab(rawTab);
+        var frame = new Frame(message.documentUrl, message.isTopLevel, rawTab);
 
         for (var i = 0; i < this._listeners.length; i++)
         {
-          var regex = this._urlPatterns[i];
-
-          if ((!regex || regex.test(message.url)) && this._listeners[i](message.url, message.type, tab, 0, -1) === false)
+          if (this._listeners[i](message.url, message.type, tab, frame) === false)
             return false;
         }
 
         return true;
       },
-      addListener: function(listener, urls)
+      addListener: function(listener)
       {
-        var regex;
-
-        if (urls)
-          regex = new RegExp("^(?:" + urls.map(function(url)
-          {
-            return url.split("*").map(function(s)
-            {
-              return s.replace(/([.?+^$[\]\\(){}|-])/g, "\\$1");
-            }).join(".*");
-          }).join("|") + ")($|[?#])");
-
         this._listeners.push(listener);
-        this._urlPatterns.push(regex);
       },
       removeListener: function(listener)
       {
         var idx = this._listeners.indexOf(listener);
-
         if (idx != -1)
-        {
           this._listeners.splice(idx, 1);
-          this._urlPatterns.splice(idx, 1);
-        }
       }
     },
     handlerBehaviorChanged: function() {}
   };
 
 
   /* Synchronous messaging */
 
   safari.application.addEventListener("message", function(event)
   {
@@ skipping 32 matching lines @@
     }
   };
 
   ext.backgroundPage = {
     getWindow: function()
     {
       return safari.extension.globalPage.contentWindow;
     }
   };
 
-  ext.onMessage = new MessageEventTarget(safari.application);
+  ext.onMessage = new BackgroundMessageEventTarget();
 
   var contextMenu = [];
   var isContextMenuHidden = false;
   ext.contextMenus = {
     addMenuItem: function(title, contexts, onclick)
     {
       contextMenu.push({
         id: "block-element", 
         title: title,
         item: null,
@@ skipping 42 matching lines @@
     for (var i = 0; i < contextMenu.length; i++)
     {
       if (contextMenu[i].id == event.command)
       {
         contextMenu[i].onclick(event.userInfo.srcUrl, new Tab(safari.application.activeBrowserWindow.activeTab));
         break;
       }
     }
   }, false);
 })();