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 isPreloadedPage = function(message, tab)
+  {
+    // the message was sent by a preloaded page if document.hidden was set, despite the tab is visible
+    return message.isDocumentHidden && tab.browserWindow.visible && tab.browserWindow.activeTab == 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

[Wladimir Palant, 2014/01/24 14:11:34]

form => from

+            // 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 (isPreloadedPage(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);

[Wladimir Palant, 2014/01/24 14:11:34]

What if a preloaded page is simply discarded? Won't we leak memory then?

[Sebastian Noack, 2014/01/24 14:17:49]

Just temporarily until another page is loaded in that tab. If that isn't enough
we could still make the TabMap remove data when the "unload" event was received
by the content script.

+              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 (isPreloadedPage(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: this._tab.browserWindow.visible &&
+                        this._tab.browserWindow.activeTab == 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 (isPreloadedPage(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);
 })();