Issue 654 - Attach pages to their tabs to improve performance on Safari

safari/ext/background.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()
 {
   /* Pages */
 
   var pages = {__proto__: null};
   var pageCounter = 0;
 
-  var Page = function(id, tab, url, prerendered)
+  var Page = function(id, tab, url)
   {
     this._id = id;
     this._tab = tab;
     this._frames = [{url: url, parent: null}];
-    this._prerendered = prerendered;
 
     if (tab.page)
       this._messageProxy = new ext._MessageProxy(tab.page);
     else
       // while the new tab page is shown on Safari 7, the 'page' property
       // of the tab is undefined, and we can't send messages to that page
       this._messageProxy = {
         handleRequest: function() {},
         handleResponse: function() {},
         sendMessage: function() {}
@@ skipping 16 matching lines @@
       this._tab.close();
     },
     sendMessage: function(message, responseCallback)
     {
       this._messageProxy.sendMessage(message, responseCallback, {pageId: this._id});
     }
   };
 
   var isPageActive = function(page)
   {
-    return page._tab == page._tab.browserWindow.activeTab && !page._prerendered;
+    var tab = page._tab;
+    return tab == tab.browserWindow.activeTab && page == tab._visiblePage;
   };
 
   var forgetPage = function(id)
   {
     ext._removeFromAllPageMaps(id);
+
+    delete pages[id]._tab._pages[id];
     delete pages[id];
   };
 
   var replacePage = function(page)
   {
-    for (var id in pages)
+    page._tab._visiblePage = page;
+
+    for (var id in page._tab._pages)
     {
-      if (id != page._id && pages[id]._tab == page._tab)
+      if (id != page._id)
         forgetPage(id);
     }
 
     if (isPageActive(page))
       updateToolbarItemForPage(page);
   };
 
   ext.pages = {
     open: function(url, callback)
     {
@@ skipping 41 matching lines @@
     // this event is dispatched on closing windows and tabs. However when a
     // window is closed, it is first dispatched on each tab in the window and
     // then on the window itself. But we are only interested in closed tabs.
     if (!(event.target instanceof SafariBrowserTab))
       return;
 
     // when a tab is closed, forget the previous page associated with that
     // tab. Note that it wouldn't be sufficient do that when the old page
     // is unloading, because Safari dispatches window.onunload only when
     // reloading the page or following links, but not when closing the tab.
-    for (var id in pages)
-    {
-      if (pages[id]._tab == event.target)
-        forgetPage(id);
-    }
+    for (var id in event.target._pages)
+      forgetPage(id);
   }, true);
 
 
   /* Browser actions */
 
   var toolbarItemProperties = {};
 
   var getToolbarItemForWindow = function(win)
   {
     for (var i = 0; i < safari.extension.toolbarItems.length; i++)
@@ skipping 63 matching lines @@
   {
     // this event is also dispatched on windows that got focused. But we
     // are only interested in tabs, which became active in their window.
     if (!(event.target instanceof SafariBrowserTab))
       return;
 
     // update the toolbar item for the page visible in the tab that just
     // became active. If we can't find that page (e.g. when a page was
     // opened in a new tab, and our content script didn't run yet), the
     // toolbar item of the window, is reset to its intial configuration.
-    var activePage = null;
-    for (var id in pages)
-    {
-      var page = pages[id];
-      if (page._tab == event.target && !page._prerendered)
-      {
-        activePage = page;
-        break;
-      }
-    }
-
-    updateToolbarItemForPage(activePage, event.target.browserWindow);
+    updateToolbarItemForPage(event.target._visiblePage, event.target.browserWindow);
   }, true);
 
 
   /* Context menus */
 
   var contextMenuItems = new ext.PageMap();
 
   var ContextMenus = function(page)
   {
     this._page = page;
@@ skipping 281 matching lines @@
     var page = null;
     var frame = null;
 
     var lastPage;
     var lastPageTopLevelFrame;
 
     // find the parent frame and its page for this sub frame,
     // by matching its referrer with the URL of frames previously
     // loaded in the same tab. If there is more than one match,
     // the most recent loaded page and frame is preferred.
-    for (var curPageId in pages)
+    for (var curPageId in (tab ? tab._pages : pages))
     {
       var curPage = pages[curPageId];
-      if (tab && curPage._tab != tab)
-        continue;
 
       for (var i = 0; i < curPage._frames.length; i++)
       {
         var curFrame = curPage._frames[i];
 
         if (curFrame.url == url)
         {
           page = curPage;
           frame = curFrame;
         }
@@ skipping 15 matching lines @@
   };
 
   safari.application.addEventListener("message", function(event)
   {
     switch (event.name)
     {
       case "canLoad":
         switch (event.message.category)
         {
           case "loading":
+            var tab = event.target;
+            var message = event.message;
+
             var pageId;
             var frameId;
 
-            if (event.message.isTopLevel)
+            if (message.isTopLevel)
             {
               pageId = ++pageCounter;
               frameId = 0;
 
-              var isPrerendered = event.message.isPrerendered;
-              var page = new Page(
-                pageId,
-                event.target,
-                event.message.url,
-                isPrerendered
-              );
+              var page = new Page(pageId, tab, message.url);
 
-              if (event.message.isPopup && !event.target._popupLoaded)
+              if (message.isPopup && !tab._popupLoaded)
               {
-                if (!("_opener" in event.target))
-                  event.target._opener = findPageAndFrame(null, event.message.referrer);
+                if (!("_opener" in tab))
+                  tab._opener = findPageAndFrame(null, message.referrer);
 
                 if (page.url != "about:blank")
-                  event.target._popupLoaded = true;
+                  tab._popupLoaded = true;
 
-                ext.pages.onPopup._dispatch(page, event.target._opener);
+                ext.pages.onPopup._dispatch(page, tab._opener);
               }
 
-              if (event.target.browserWindow)
+              if (tab.browserWindow)
               {
-                pages[pageId] = page;
+                pages[pageId] = (tab._pages || (tab._pages = {__proto__: null}))[pageId] = page;

[Wladimir Palant, 2014/06/11 08:17:10]

Seriously, don't be too clever - go for readable code instead.

if (!tab._pages)
  tab._pages = {__proto__: null};
pages[pageId] = tab._pages[pageId] = page;

 
                 // when a new page is shown, forget the previous page associated
                 // with its tab, and reset the toolbar item if necessary.
                 // Note that it wouldn't be sufficient to do that when the old
                 // page is unloading, because Safari dispatches window.onunload
                 // only when reloading the page or following links, but not when
                 // you enter a new URL in the address bar.
-                if (!isPrerendered)
+                if (!message.isPrerendered)
                   replacePage(page);
 
                 ext.pages.onLoading._dispatch(page);
               }
             }
             else
             {
-              var parent = findPageAndFrame(event.target, event.message.referrer);
+              var parent = findPageAndFrame(tab, message.referrer);
 
               pageId  = parent.page._id;
               frameId = parent.page._frames.length;
 
-              parent.page._frames.push({
-                url: event.message.url,
-                parent: parent.frame
-              });
+              parent.page._frames.push({url: message.url, parent: parent.frame});
             }
 
             event.message = {pageId: pageId, frameId: frameId};
             break;
           case "webRequest":
             var page = pages[event.message.pageId];
 
             event.message = ext.webRequest.onBeforeRequest._dispatch(
               event.message.url,
               event.message.type,
               page,
               page._frames[event.message.frameId]
             );
             break;
           case "proxy":
             event.message = backgroundPageProxy.handleMessage(event.message);
             break;
         }
         break;
       case "request":
         var page = pages[event.message.pageId];
         var sender = {page: page, frame: page._frames[event.message.frameId]};
         page._messageProxy.handleRequest(event.message, sender);
         break;
       case "response":
         pages[event.message.pageId]._messageProxy.handleResponse(event.message);
         break;
       case "replaced":
-        var page = pages[event.message.pageId];
-        page._prerendered = false;
-
         // when a prerendered page is shown, forget the previous page
         // associated with its tab, and reset the toolbar item if necessary.
         // Note that it wouldn't be sufficient to do that when the old
         // page is unloading, because Safari dispatches window.onunload
         // only when reloading the page or following links, but not when
         // the current page is replaced with a prerendered page.
-        replacePage(page);
+        replacePage(pages[event.message.pageId]);
         break;
     }
   });
 
 
   /* Storage */
 
   ext.storage = safari.extension.settings;
 })();