Issue 3788 - Keep track of Safari tabs without canLoad

safari/ext/background.js

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2016 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()
 {
   /* Context menus */
 
   var contextMenuItems = new ext.PageMap();
+  var lastContextMenuTab;
 
   var ContextMenus = function(page)
   {
     this._page = page;
   };
   ContextMenus.prototype = {
     create: function(item)
     {
       var items = contextMenuItems.get(this._page);
       if (!items)
         contextMenuItems.set(this._page, items = []);
 
       items.push(item);
     },
     remove: function(item)
     {
       let items = contextMenuItems.get(this._page);
       if (items)
       {
         let index = items.indexOf(item);
         if (index != -1)
           items.splice(index, 1);
       }
     }
   };
 
   safari.application.addEventListener("contextmenu", function(event)
   {
+    lastContextMenuTab = event.target;
+
     if (!event.userInfo)
       return;
 
-    var pageId = event.userInfo.pageId;
-    if (!pageId)
+    var documentId = event.userInfo.documentId;
+    if (!documentId)
       return;
 
-    var page = pages[event.userInfo.pageId];
+    var page = pages[event.target._documentLookup[documentId].pageId];
     var items = contextMenuItems.get(page);
     if (!items)
       return;
 
     var context = event.userInfo.tagName;
     if (context == "img")
       context = "image";
 
     for (var i = 0; i < items.length; i++)
     {
       // Supported contexts are: all, audio, image, video
       var menuItem = items[i];
       if (menuItem.contexts.indexOf("all") == -1 && menuItem.contexts.indexOf(context) == -1)
         continue;
 
       event.contextMenu.appendContextMenuItem(i, menuItem.title);
     }
   });
 
   safari.application.addEventListener("command", function(event)
   {
-    var page = pages[event.userInfo.pageId];
+    var documentId = event.userInfo.documentId;
+    var page = pages[lastContextMenuTab._documentLookup[documentId].pageId];
     var items = contextMenuItems.get(page);
 
     items[event.command].onclick(page);
   });
 
 
   /* Browser actions */
 
   var toolbarItemProperties = {};
 
@@ skipping 106 matching lines @@
     this.browserAction = new BrowserAction(this);
     this.contextMenus = new ContextMenus(this);
   };
   Page.prototype = {
     get url()
     {
       return this._frames[0].url;
     },
     sendMessage: function(message, responseCallback)
     {
-      this._messageProxy.sendMessage(message, responseCallback, {pageId: this.id});
+      var documentIds = [];
+      for (var documentId in this._tab._documentLookup)
+        if (this._tab._documentLookup[documentId].pageId == this.id)
+          documentIds.push(documentId);
+
+      this._messageProxy.sendMessage(message, responseCallback,
+                                     {targetDocuments: documentIds});
     }
   };
 
   ext.getPage = function(id)
   {
     return pages[id];
   };
 
   var isPageActive = function(page)
   {
     var tab = page._tab;
     var win = tab.browserWindow;
     return win && tab == win.activeTab && page == tab._visiblePage;
   };
 
   var forgetPage = function(id)
   {
     ext.pages.onRemoved._dispatch(id);
 
     ext._removeFromAllPageMaps(id);
 
-    delete pages[id]._tab._pages[id];
+    var tab = pages[id]._tab;
+
+    for (var documentId in tab._documentLookup)
+    {
+      if (tab._documentLookup[documentId].pageId == id)
+        delete tab._documentLookup[documentId];
+    }
+
+    delete tab._pages[id];
     delete pages[id];
   };
 
   var replacePage = function(page)
   {
     var tab = page._tab;
     tab._visiblePage = page;
 
     for (var id in tab._pages)
     {
       if (id != page.id)
         forgetPage(id);
     }
 
     if (isPageActive(page))
       updateToolbarItemForPage(page, tab.browserWindow);
   };
 
   var addPage = function(tab, url, prerendered)
   {
     var pageId = ++pageCounter;
 
     if (!('_pages' in tab))
       tab._pages = Object.create(null);
 
+    if (!('_documentLookup' in tab))
+      tab._documentLookup = Object.create(null);
+
     var page = new Page(pageId, tab, url);
     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 (!prerendered)
@@ skipping 68 matching lines @@
   // use  Safari's extension API to detect existing tabs.
   safari.application.browserWindows.forEach(function(win)
   {
     for (var i = 0; i < win.tabs.length; i++)
     {
       var tab = win.tabs[i];
       var url = tab.url;
 
       // For the new tab page the url property is undefined.
       if (url)
-        addPage(tab, url, false);
+      {
+        var pageId = addPage(tab, url, false);
+        tab.page.dispatchMessage("requestDocumentId", {pageId: pageId});
+      }
     }
   });
 
 
   /* Web requests */
 
   ext.webRequest = {
     onBeforeRequest: new ext._EventTarget(),
     handlerBehaviorChanged: function()
     {
@@ skipping 64 matching lines @@
       return function()
       {
         var page = pages[pageId];
         if (!page)
           return;
 
         var objects = proxy.cache.get(page);
         if (!objects)
           return;
 
+        var targetDocument;
+        for (var documentId in page._tab._documentLookup)
+        {
+          var result = page._tab._documentLookup[documentId];
+          if (result.pageId == pageId && result.frameId == frameId)
+          {
+            targetDocument = documentId;
+            break;
+          }
+        }
+        if (!targetDocument)
+          return;
+
         page._tab.page.dispatchMessage("proxyCallback",
         {
-          pageId: pageId,
-          frameId: frameId,
+          targetDocuments: [targetDocument],
           callbackId: callbackId,
           contextId: proxy.registerObject(this, objects),
           args: proxy.serializeSequence(arguments, objects)
         });
       };
     },
-    deserialize: function(spec, objects, pageId, memo)
+    deserialize: function(spec, objects, pageId, frameId, memo)
     {
       switch (spec.type)
       {
         case "value":
           return spec.value;
         case "hosted":
           return objects[spec.objectId];
         case "callback":
-          return this.createCallback(spec.callbackId, pageId, spec.frameId);
+          return this.createCallback(spec.callbackId, pageId, frameId);
         case "object":
         case "array":
           if (!memo)
             memo = {specs: [], objects: []};
 
           var idx = memo.specs.indexOf(spec);
           if (idx != -1)
             return memo.objects[idx];
 
           var obj;
           if (spec.type == "array")
             obj = [];
           else
             obj = {};
 
           memo.specs.push(spec);
           memo.objects.push(obj);
 
           if (spec.type == "array")
             for (var i = 0; i < spec.items.length; i++)
-              obj.push(this.deserialize(spec.items[i], objects, pageId, memo));
+              obj.push(this.deserialize(spec.items[i], objects,
+                                        pageId, frameId, memo));
           else
             for (var k in spec.properties)
-              obj[k] = this.deserialize(spec.properties[k], objects, pageId, memo);
+              obj[k] = this.deserialize(spec.properties[k], objects,
+                                        pageId, frameId, memo);
 
           return obj;
       }
     },
     getObjectCache: function(page)
     {
       var objects = this.cache.get(page);
       if (!objects)
       {
         objects = [window];
@@ skipping 21 matching lines @@
             var value = obj[message.property];
           }
           catch (e)
           {
             return this.fail(e);
           }
 
           return {succeed: true, result: this.serialize(value, objects)};
         case "setProperty":
           var obj = objects[message.objectId];
-          var value = this.deserialize(message.value, objects, message.pageId);
+          var value = this.deserialize(message.value, objects,
+                                       message.pageId, message.frameId);
 
           try
           {
             obj[message.property] = value;
           }
           catch (e)
           {
             return this.fail(e);
           }
 
           return {succeed: true};
         case "callFunction":
           var func = objects[message.functionId];
           var context = objects[message.contextId];
 
           var args = [];
           for (var i = 0; i < message.args.length; i++)
-            args.push(this.deserialize(message.args[i], objects, message.pageId));
+            args.push(this.deserialize(message.args[i], objects,
+                                       message.pageId, message.frameId));
 
           try
           {
             var result = func.apply(context, args);
           }
           catch (e)
           {
             return this.fail(e);
           }
 
@@ skipping 21 matching lines @@
           return objectInfo;
       }
     }
   };
 
 
   /* Message processing */
 
   safari.application.addEventListener("message", function(event)
   {
+    var tab = event.target;
+    var message = event.message;
+    var sender;
+    if ("documentId" in message && "_documentLookup" in tab)
+    {
+      sender = tab._documentLookup[message.documentId];
+      if (sender)
+      {
+        sender.page = pages[sender.pageId];
+        sender.frame = sender.page._frames[sender.frameId];
+      }
+    }
+
     switch (event.name)
     {
       case "canLoad":
-        switch (event.message.category)
+        switch (message.category)
         {
-          case "loading":
-            var tab = event.target;
-            var message = event.message;
-
-            var pageId;
-            var frameId;
-
-            if (message.isTopLevel)
-            {
-              pageId = addPage(tab, message.url, message.isPrerendered);
-              frameId = 0;
-
-              ext.pages.onLoading._dispatch(pages[pageId]);
-            }
-            else
-            {
-              var page;
-              var parentFrame;
-
-              var lastPageId;
-              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 tab._pages)
-              {
-                var curPage = pages[curPageId];
-
-                for (var i = 0; i < curPage._frames.length; i++)
-                {
-                  var curFrame = curPage._frames[i];
-
-                  if (curFrame.url.href == message.referrer)
-                  {
-                    pageId = curPageId;
-                    page = curPage;
-                    parentFrame = curFrame;
-                  }
-
-                  if (i == 0)
-                  {
-                    lastPageId = curPageId;
-                    lastPage = curPage;
-                    lastPageTopLevelFrame = curFrame;
-                  }
-                }
-              }
-
-              // if we can't find the parent frame and its page, fall back to
-              // the page most recently loaded in the tab and its top level frame
-              if (!page)
-              {
-                pageId = lastPageId;
-                page = lastPage;
-                parentFrame = lastPageTopLevelFrame;
-              }
-
-              frameId = page._frames.length;
-              page._frames.push({url: new URL(message.url), parent: parentFrame});
-            }
-            event.message = {pageId: pageId, frameId: frameId};
-            break;
           case "webRequest":
-            var page = pages[event.message.pageId];
-            var frame = page._frames[event.message.frameId];
-
             var results = ext.webRequest.onBeforeRequest._dispatch(
-              new URL(event.message.url, frame.url),
-              event.message.type, page, frame
+              new URL(message.url, sender.frame.url),
+              message.type, sender.page, sender.frame
             );
 
             event.message = (results.indexOf(false) == -1);
             break;
           case "proxy":
-            event.message = backgroundPageProxy.handleMessage(event.message);
+            message.pageId = sender.pageId;
+            message.frameId = sender.frameId;
+            event.message = backgroundPageProxy.handleMessage(message);
             break;
           case "request":
-            var page = pages[event.message.pageId];
-            var sender = {page: page, frame: page._frames[event.message.frameId]};
-
             var response = null;
             var sendResponse = function(message) { response = message; };
 
-            ext.onMessage._dispatch(event.message.payload, sender, sendResponse);
+            ext.onMessage._dispatch(message.payload, sender, sendResponse);
 
             event.message = response;
             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);
+        sender.page._messageProxy.handleRequest(message, sender);
         break;
       case "response":
-        pages[event.message.pageId]._messageProxy.handleResponse(event.message);
+        // All documents within a page have the same pageId and that's all we
+        // care about here.
+        var pageId = tab._documentLookup[message.targetDocuments[0]].pageId;
+        pages[pageId]._messageProxy.handleResponse(message);
         break;
       case "replaced":
         // 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(pages[event.message.pageId]);
+        replacePage(sender.page);
+        break;
+      case "loading":
+        var pageId;
+        var frameId;
+        var documentId = message.documentId;
+
+        if (message.isTopLevel)
+        {
+          pageId = addPage(tab, message.url, message.isPrerendered);
+          frameId = 0;
+
+          ext.pages.onLoading._dispatch(pages[pageId]);
+        }
+        else
+        {
+          var page;
+          var parentFrame;
+
+          var lastPageId;
+          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 tab._pages)
+          {
+            var curPage = pages[curPageId];
+
+            for (var i = 0; i < curPage._frames.length; i++)
+            {
+              var curFrame = curPage._frames[i];
+
+              if (curFrame.url.href == message.referrer)
+              {
+                pageId = curPageId;
+                page = curPage;
+                parentFrame = curFrame;
+              }
+
+              if (i == 0)
+              {
+                lastPageId = curPageId;
+                lastPage = curPage;
+                lastPageTopLevelFrame = curFrame;
+              }
+            }
+          }
+
+          // if we can't find the parent frame and its page, fall back to
+          // the page most recently loaded in the tab and its top level frame
+          if (!page)
+          {
+            pageId = lastPageId;
+            page = lastPage;
+            parentFrame = lastPageTopLevelFrame;
+          }
+
+          frameId = page._frames.length;
+          page._frames.push({url: new URL(message.url), parent: parentFrame});
+        }
+
+        tab._documentLookup[documentId] = {pageId: pageId, frameId: frameId};
+        break;
+      case "documentId":
+        tab._documentLookup[message.documentId] = {
+          pageId: message.pageId, frameId: 0
+        };
         break;
     }
   });
 
 
   /* Storage */
 
   ext.storage = {
     get: function(keys, callback)
     {
@@ skipping 66 matching lines @@
   /* Windows */
   ext.windows = {
     // Safari doesn't provide as rich a windows API as Chrome does, so instead
     // of chrome.windows.create we have to fall back to just opening a new tab.
     create: function(createData, callback)
     {
       ext.pages.open(createData.url, callback);
     }
   };
 })();