Deal with preloadded pages in Safari 7.0

safari/ext/content.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()
 {
   if (window == window.top)
-    safari.self.tab.dispatchMessage("loading");
+    safari.self.tab.dispatchMessage("loading", {isDocumentHidden: document.hidden});
 
 
   /* Events */
 
   var ContentMessageEventTarget = function()
   {
     MessageEventTarget.call(this, safari.self);
   };
   ContentMessageEventTarget.prototype = {
     __proto__: MessageEventTarget.prototype,
     _getResponseDispatcher: function(event)
     {
       return event.target.tab;
     },
     _getSenderDetails: function(event)
     {
       return {};
+    },
+    _ignoreIf: function(event)
+    {
+      // If the current page is a preloaded page in Safari 7.0, we have to
+      // ignore all messages sent from the background page. The high-level code
+      // doesn't know anything about preloaded pages and expects messages to be
+      // handled only by the current visible page.
+      return document.hidden && event.message.isTabVisible;
     }
   };
 
 
   /* Background page proxy */
   var proxy = {
     objects: [],
     callbacks: [],
 
     send: function(message)
@@ skipping 223 matching lines @@
       if (objectInfo.isFunction)
         obj.prototype = this.getProperty(objectId, "prototype");
 
       return obj;
     }
   };
 
 
   /* Web request blocking */
 
-  document.addEventListener("beforeload", function(event)
+  var canLoad = function(event)
   {
     var type;
-
-    switch(event.target.localName)
+    switch (event.target.localName)
     {
       case "frame":
       case "iframe":
         type = "sub_frame";
         break;
       case "img":
         type = "image";
         break;
       case "object":
       case "embed":
         type = "object";
         break;
       case "script":
         type = "script";
         break;
       case "link":
         if (/\bstylesheet\b/i.test(event.target.rel))
         {
           type = "stylesheet";
           break;
         }
       default:
         type = "other";
     }
 
-    if (!safari.self.tab.canLoad(
+    return safari.self.tab.canLoad(
       event, {
         type: "webRequest",
         payload: {
           url: event.url,
           type: type,
           documentUrl: document.location.href,
-          isTopLevel: window == window.top
+          isTopLevel: window == window.top,
+          isDocumentHidden: document.hidden
         }
       }
-    ))
+    );
+  };
+
+  document.addEventListener("beforeload", function(event)
+  {
+    var result;
+    if (event.target._blocked || (result = canLoad(event)) == "blocked")
     {
       event.preventDefault();
 
       // Safari doesn't dispatch an "error" or "load" event when preventing an
       // element from loading by cancelling the "beforeload" event. So we have
       // to dispatch it manually. Otherwise element collapsing wouldn't work.
       var evt = document.createEvent("Event");
-      evt.initEvent(type == "sub_frame" ? "load" : "error");
+      evt.initEvent(/^i?frame$/.test(event.target.localName) ? "load" : "error");
       event.target.dispatchEvent(evt);
     }
+    else if (result == "deferred")
+      deferredBeforeLoadEvents.push(event);
   }, true);
 
 
   /* API */
 
   ext.backgroundPage = {
     sendMessage: function(message, responseCallback)
     {
       _sendMessage(
-        message, responseCallback,
-        safari.self.tab, safari.self,
+        // message payload
+        message,
+        // response callback
+        function(response)
+        {
+          if (response.deferred)
+            deferredMessages.push([message, responseCallback]);
+          else if (responseCallback)
+            responseCallback(response.payload);
+        },
+        // message dispatcher
+        safari.self.tab,
+        // response event target
+        safari.self,
+        // extra data
         {
           documentUrl: document.location.href,
-          isTopLevel: window == window.top
+          isTopLevel: window == window.top,
+          isDocumentHidden: document.hidden
         }
       );
     },
     getWindow: function()
     {
       return proxy.getObject(0);
     }
   };
 
   ext.onMessage = new ContentMessageEventTarget();
 
 
+  // Starting with Safari 7.0 content scripts also run in preloaded pages.
+  // However our high-level code doesn't know anything about preloaded pages
+  // and expects only one page running in each tab. So we have to defer
+  // all requests to the background page, until the preloaded page is shown.
+
+  var deferredMessages = [];
+  var deferredBeforeLoadEvents = [];
+
+  document.addEventListener("visibilitychange", function()
+  {
+    if (document.hidden)
+      return;
+
+    // notify background page, that it can catch up on onLoading events
+    if (window == window.top)
+      safari.self.tab.dispatchMessage("show");
+
+    // catch up on deferred messages
+    for (var i = 0; i < deferredMessages.length; i++)
+      ext.backgroundPage.sendMessage.apply(null, deferredMessages[i]);
+    deferredMessages = [];
+
+    // catch up on deferred resource blocking
+    for (var i = 0; i < deferredBeforeLoadEvents.length; i++)
+    {
+      var result = canLoad(deferredBeforeLoadEvents[i]);
+      if (result == "blocked")
+      {
+        // if at least one script was supposed to be blocked,
+        // we have to reload the preloaded page. Executed scripts
+        // won't undo themselves by removing them from the DOM
+        var element = deferredBeforeLoadEvents[i].target;
+        if (element.localName == "script")
+        {
+          document.documentElement.style.display = "none";
+          document.location.reload();
+          return;
+        }
+
+        // other resources that were supposed to be blocked are replaced
+        // with an identical clone, in order to trigger "beforeload" again
+        if (element.parentNode)
+        {
+          var clone = element.cloneNode(true);
+          clone._blocked = true;  // remember that this should be blocked,
+                                  // to avoid checking twice
+          element.parentNode.replaceChild(clone, element);
+        }
+      }
+    }
+    deferredBeforeLoadEvents = [];
+  });
+
+
   // Safari does not pass the element which the context menu is refering to
   // so we need to add it to the event's user info.
   document.addEventListener("contextmenu", function(event)
   {
     var element = event.srcElement;
     safari.self.tab.setContextMenuEventUserInfo(event, {
       srcUrl: ("src" in element) ? element.src : null,
       tagName: element.localName
     });
   }, false);
 })();