Deal with preloadded pages in Safari 7.0

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()
 {
+  var isTabVisible = function(tab)
+  {
+    return tab.browserWindow.visible && tab.browserWindow.activeTab == tab;
+  };
+
+  var sentByPreloadedPage = function(message, tab)
+  {
+    // the message was sent by a preloaded page if document.hidden was set,
+    // despite the tab is visible
+    return message.isDocumentHidden && isTabVisible(tab);
+  };
+
+
   /* Events */
 
   var TabEventTarget = function()
   {
     WrappedEventTarget.apply(this, arguments);
   };
   TabEventTarget.prototype = {
     __proto__: WrappedEventTarget.prototype,
     _wrapListener: function(listener)
     {
       return function(event)
       {
         if (event.target instanceof SafariBrowserTab)
           listener(new Tab(event.target));
       };
     }
   };
 
   var LoadingTabEventTarget = function(target)
   {
     WrappedEventTarget.call(this, target, "message", false);
+    this._preloadedTabs = new TabMap();
   };
   LoadingTabEventTarget.prototype = {
     __proto__: WrappedEventTarget.prototype,
     _wrapListener: function(listener)
     {
       return function (event)
       {
-        if (event.name == "loading")
-          listener(new Tab(event.target));
-      };
+        switch (event.name)
+        {
+          case "loading":
+            var tab = new Tab(event.target);
+
+            // when the "loading" message was sent form a preloaded
+            // page in Safari 7.0, we have to wait until the page is
+            // shown, before calling the listener. The high-level code
+            // doesn't know anything about preloaded pages and expects
+            // all events to be related to the current visible page.
+            if (sentByPreloadedPage(event.message, event.target))
+              this._preloadedTabs.set(tab, null);
+            else
+            {
+              this._preloadedTabs.delete(tab);
+              listener(tab);
+            }
+
+            break;
+          case "show":
+            var tab = new Tab(event.target);
+
+            if (this._preloadedTabs.has(tab))
+            {
+              this._preloadedTabs.delete(tab);
+              listener(tab);
+            }
+        }
+      }.bind(this);
     }
   };
 
   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
         )
       };
+    },
+    _ignoreIf: function(event)
+    {
+      // when receiving a message from a preloaded page in Safari 7.0, we
+      // have to defer procesing of that message, until the page is shown.
+      // The  high-level code doesn't know anything about preloaded pages
+      // and expects all message to be sent from the current visible page.
+      if (sentByPreloadedPage(event.message, event.target))
+      {
+        event.target.page.dispatchMessage("response", {
+          requestId: event.message.requestId,
+          deferred: true
+        });
+        return true;
+      }
+
+      return false;
     }
   };
 
 
   /* Tabs */
 
   Tab = function(tab)
   {
     this._tab = tab;
 
@@ skipping 13 matching lines @@
     {
       this._tab.close();
     },
     activate: function()
     {
       this._tab.activate();
     },
     sendMessage: function(message, responseCallback)
     {
       _sendMessage(
-        message, responseCallback,
-        this._tab.page, this._tab
+        // message payload
+        message,
+        // response callback
+        responseCallback && function(response) { responseCallback(response.payload); },
+        // message dispatcher
+        this._tab.page,
+        // response event target
+        this._tab,
+        // extra data
+        {
+          isTabVisible: isTabVisible(this._tab)
+        }
       );
     }
   };
 
   TabMap = function(deleteOnPageUnload)
   {
     this._data = [];
     this._deleteOnPageUnload = deleteOnPageUnload;
 
     this.delete = this.delete.bind(this);
@@ skipping 448 matching lines @@
 
 
   /* Web request blocking */
 
   ext.webRequest = {
     onBeforeRequest: {
       _listeners: [],
 
       _handleMessage: function(message, rawTab)
       {
+        // we have to defer loading of resources on preloaded pages
+        // in Safari 7.0, until the page is shown. The high-level code
+        // doesn't know anything about preloaded pages and expects all
+        // web requests to be related to the current visible page.
+        if (sentByPreloadedPage(message, rawTab))
+          return "deferred";
+
         var tab = new Tab(rawTab);
         var frame = new Frame(message.documentUrl, message.isTopLevel, rawTab);
 
         for (var i = 0; i < this._listeners.length; i++)
         {
           if (this._listeners[i](message.url, message.type, tab, frame) === false)
-            return false;
+            return "blocked";
         }
 
-        return true;
+        return "ok";
       },
       addListener: function(listener)
       {
         this._listeners.push(listener);
       },
       removeListener: function(listener)
       {
         var idx = this._listeners.indexOf(listener);
         if (idx != -1)
           this._listeners.splice(idx, 1);
@@ skipping 109 matching lines @@
     for (var i = 0; i < contextMenuItems.length; i++)
     {
       if (contextMenuItems[i].id == event.command)
       {
         contextMenuItems[i].onclick(event.userInfo.srcUrl, new Tab(safari.application.activeBrowserWindow.activeTab));
         break;
       }
     }
   }, false);
 })();