Refactored the abstraction layer to address prerendered pages on Safari caused by leaky abstraction

safari/ext/content.js

 /*
  * This file is part of Adblock Plus <http://adblockplus.org/>,
  * Copyright (C) 2006-2014 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()
 {
   // the safari object is missing in frames created from javascript: URLs.
   // So we have to fallback to the safari object from the parent frame.
   if (!("safari" in window))
     window.safari = window.parent.safari;
 
-  if (window == window.top)
-    safari.self.tab.dispatchMessage("loading");
+
+  /* Intialization */
+
+  var beforeLoadEvent = document.createEvent("Event");
+  beforeLoadEvent.initEvent("beforeload");
+
+  var isTopLevel = window == window.top;
+  var isPrerendered = document.visibilityState == "prerender";
+
+  var documentInfo = safari.self.tab.canLoad(
+    beforeLoadEvent,
+    {
+      category: "loading",
+      url: document.location.href,
+      referrer: document.referrer,
+      isTopLevel: isTopLevel,
+      isPrerendered: isPrerendered
+    }
+  );
+
+  if (isTopLevel && isPrerendered)
+  {
+    var onVisibilitychange = function()
+    {
+      safari.self.tab.dispatchMessage("replaced", {pageId: documentInfo.pageId});
+      document.removeEventListener("visibilitychange", onVisibilitychange);
+    };
+    document.addEventListener("visibilitychange", onVisibilitychange);
+  }
 
 
-  /* Events */
+  /* Web requests */
 
-  var ContentMessageEventTarget = function()
+  document.addEventListener("beforeload", function(event)
   {
-    MessageEventTarget.call(this, safari.self);
-  };
-  ContentMessageEventTarget.prototype = {
-    __proto__: MessageEventTarget.prototype,
-    _getResponseDispatcher: function(event)
+    // we don't block non-HTTP requests anyway, so we can bail out
+    // without asking the background page. This is even necessary
+    // because passing large data (like a photo encoded as data: URL)
+    // to the background page, freezes Safari.
+    if (!/^https?:/.test(event.url))
+      return;
+
+    var type;
+    switch(event.target.localName)
     {
-      return event.target.tab;
-    },
-    _getSenderDetails: function(event)
+      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(
+      event, {
+        category: "webRequest",
+        url: event.url,
+        type: type,
+        pageId: documentInfo.pageId,
+        frameId: documentInfo.frameId
+      }
+    ))
     {
-      return {};
+      event.preventDefault();
+
+      // Safari doesn't dispatch an "error" 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.
+      if (type != "sub_frame")
+      {
+        var evt = document.createEvent("Event");
+        evt.initEvent(type == "error");
+        event.target.dispatchEvent(evt);
+      }
     }
-  };
+  }, true);
 
 
-  /* Background page proxy */
-  var proxy = {
+  /* Context menus */
+
+  document.addEventListener("contextmenu", function(event)
+  {
+    var element = event.srcElement;
+    safari.self.tab.setContextMenuEventUserInfo(event, {
+      pageId: documentInfo.pageId,
+      srcUrl: ("src" in element) ? element.src : null,
+      tagName: element.localName
+    });
+  });
+
+
+  /* Background page */
+
+  var backgroundPageProxy = {
     objects: [],
     callbacks: [],
 
     send: function(message)
     {
-      var evt = document.createEvent("Event");
-      evt.initEvent("beforeload");
-      return safari.self.tab.canLoad(evt, {type: "proxy", payload: message});
+      message.category = "proxy";
+      message.pageId = documentInfo.pageId;
+
+      return safari.self.tab.canLoad(beforeLoadEvent, message);
     },
     checkResult: function(result)
     {
       if (!result.succeed)
         throw result.error;
     },
     deserializeResult: function(result)
     {
       this.checkResult(result);
       return this.deserialize(result.result);
     },
     serialize: function(obj, memo)
     {
       var objectId = this.objects.indexOf(obj);
       if (objectId != -1)
         return {type: "hosted", objectId: objectId};
 
       if (typeof obj == "function")
       {
         var callbackId = this.callbacks.indexOf(obj);
-
         if (callbackId == -1)
-        {
           callbackId = this.callbacks.push(obj) - 1;
 
-          safari.self.addEventListener("message", function(event)
-          {
-            if (event.name == "proxyCallback")
-            if (event.message.callbackId == callbackId)
-              obj.apply(
-                this.getObject(event.message.contextId),
-                this.deserializeSequence(event.message.args)
-              );
-          }.bind(this));
-        }
-
-        return {type: "callback", callbackId: callbackId};
+        return {type: "callback", callbackId: callbackId, frameId: documentInfo.frameId};
       }
 
       if (typeof obj == "object" &&
           obj != null &&
           obj.constructor != Date &&
           obj.constructor != RegExp)
       {
         if (!memo)
           memo = {specs: [], objects: []};
 
@@ skipping 114 matching lines @@
             functionId: objectId,
             contextId: proxy.getObjectId(this),
             args: Array.prototype.map.call(
               arguments,
               proxy.serialize.bind(proxy)
             )
           })
         );
       };
     },
-    getObject: function(objectId) {
+    handleCallback: function(message)
+    {
+      this.callbacks[message.callbackId].apply(
+        this.getObject(message.contextId),
+        this.deserializeSequence(message.args)
+      );
+    },
+    getObject: function(objectId)
+    {
       var objectInfo = this.send({
         type: "inspectObject",
         objectId: objectId
       });
 
       var obj = this.objects[objectId];
       if (obj)
         Object.getOwnPropertyNames(obj).forEach(function(prop) { delete obj[prop]; });
       else
       {
@@ skipping 34 matching lines @@
             property, objectInfo.properties[property].enumerable
           ));
 
       if (objectInfo.isFunction)
         obj.prototype = this.getProperty(objectId, "prototype");
 
       return obj;
     }
   };
 
+  ext.backgroundPage = {
+    sendMessage: function(message, responseCallback)
+    {
+      messageProxy.sendMessage(message, responseCallback, documentInfo);
+    },
+    getWindow: function()
+    {
+      return backgroundPageProxy.getObject(0);
+    }
+  };
+
 
-  /* Web request blocking */
+  /* Message processing */
 
-  document.addEventListener("beforeload", function(event)
+  var messageProxy = new ext._MessageProxy(safari.self.tab);
+
+  safari.self.addEventListener("message", function(event)
   {
-    // we don't block non-HTTP requests anyway, so we can bail out
-    // without asking the background page. This is even necessary
-    // because passing large data (like a photo encoded as data: URL)
-    // to the background page, freezes Safari.
-    if (!/^https?:/.test(event.url))
-      return;
+    if (event.message.pageId == documentInfo.pageId)
+    {
+      if (event.name == "request")
+      {
+        messageProxy.handleRequest(event.message, {});
+        return;
+      }
 
-    var type;
-
-    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))
+      if (event.message.frameId == documentInfo.frameId)
+      {
+        switch (event.name)
         {
-          type = "stylesheet";
-          break;
-        }
-      default:
-        type = "other";
-    }
-
-    if (!safari.self.tab.canLoad(
-      event, {
-        type: "webRequest",
-        payload: {
-          url: event.url,
-          type: type,
-          documentUrl: document.location.href,
-          isTopLevel: window == window.top
+          case "response":
+            messageProxy.handleResponse(event.message);
+            break;
+          case "proxyCallback":
+            backgroundPageProxy.handleCallback(event.message);
+            break;
         }
       }
-    ))
-    {
-      event.preventDefault();
-
-      // Safari doesn't dispatch an "error" 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.
-      if (type != "sub_frame")
-      {
-        var evt = document.createEvent("Event");
-        evt.initEvent("error");
-        event.target.dispatchEvent(evt);
-      }
     }
-  }, true);
-
-
-  /* API */
-
-  ext.backgroundPage = {
-    sendMessage: function(message, responseCallback)
-    {
-      _sendMessage(
-        message, responseCallback,
-        safari.self.tab, safari.self,
-        {
-          documentUrl: document.location.href,
-          isTopLevel: window == window.top
-        }
-      );
-    },
-    getWindow: function()
-    {
-      return proxy.getObject(0);
-    }
-  };
-
-  ext.onMessage = new ContentMessageEventTarget();
-
-
-  // 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);
+  });
 })();