Issue 1801 - Use URL objects to process URLs in the background page

chrome/ext/background.js

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2015 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 Page = ext.Page = function(tab)
   {
     this._id = tab.id;
+    this._url = tab.url && new URL(tab.url);
 
     this.browserAction = new BrowserAction(tab.id);
     this.contextMenus = new ContextMenus(this);
-
-    // Usually Page objects are created from Chrome's Tab objects, which
-    // provide the url. So we can override the fallback implemented below.
-    if (tab.url)
-      Object.defineProperty(this, "url", {value: new URL(tab.url), enumerable: true});

[Wladimir Palant, 2015/02/09 12:54:29]

Code that belongs together should really be together. Please move that logic
back into the getter - with caching if you prefer, but I don't really see
caching being necessary here.

[Sebastian Noack, 2015/02/11 10:55:51]

Whatever.

   };
   Page.prototype = {
     get url()
     {
-      // Sometimes we only have the tab id when we create a Page object.
-      // In that case we get the url from top frame of the tab, recorded
-      // by the onBeforeRequest handler.
+      // usually our Page objects are created from Chrome's Tab objects, which
+      // provide the url. So we can return the url given in the constructor.
+      if (this._url)
+        return this._url;
+
+      // but sometimes we only have the tab id when we create a Page object.
+      // In that case we get the url from top frame of the tab, recorded by
+      // the onBeforeRequest handler.
       var frames = framesOfTabs[this._id];
       if (frames)
       {
         var frame = frames[0];
         if (frame)
           return frame.url;
       }
     },
     sendMessage: function(message, responseCallback)
     {
@@ skipping 53 matching lines @@
 
   chrome.tabs.onUpdated.addListener(function(tabId, changeInfo, tab)
   {
     if (changeInfo.status == "loading")
       ext.pages.onLoading._dispatch(new Page(tab));
   });
 
   chrome.webNavigation.onBeforeNavigate.addListener(function(details)
   {
     if (details.frameId == 0)
+    {
       ext._removeFromAllPageMaps(details.tabId);
+
+      chrome.tabs.get(details.tabId, function()
+      {
+        // If the tab is prerendered, chrome.tabs.get() sets
+        // chrome.runtime.lastError and we have to dispatch the onLoading event,
+        // since the onUpdated event isn't dispatched for prerendered tabs.
+        // However, we have to keep relying on the unUpdated event for tabs that
+        // are already visible. Otherwise browser action changes get overridden
+        // when Chrome automatically resets them on navigation.
+        if (chrome.runtime.lastError)
+        {
+          ext.pages.onLoading._dispatch(
+            new Page({
+              id: details.tabId,
+              url: details.url
+            })
+          );
+        }
+      });
+    }
   });
 
-  chrome.tabs.onRemoved.addListener(function(tabId)
+  function forgetTab(tabId)
   {
     ext._removeFromAllPageMaps(tabId);
     delete framesOfTabs[tabId];
+  }
+
+  chrome.tabs.onReplaced.addListener(function(addedTabId, removedTabId)
+  {
+    forgetTab(removedTabId);
   });
 
+  chrome.tabs.onRemoved.addListener(forgetTab);
+
 
   /* Browser actions */
 
   var BrowserAction = function(tabId)
   {
     this._tabId = tabId;
+    this._changes = null;
   };
   BrowserAction.prototype = {
-    setIcon: function(path)
-    {
-      var paths = {};
-      for (var i = 1; i <= 2; i++)
-      {
-        var size = i * 19;
-        paths[size] = path.replace("$size", size);
-      }
-
-      chrome.browserAction.setIcon({tabId: this._tabId, path: paths});
-    },
-    setBadge: function(badge)
-    {
-      if (!badge)
+    _applyChanges: function()
+    {
+      if ("iconPath" in this._changes)
+      {
+        chrome.browserAction.setIcon({
+          tabId: this._tabId,
+          path: {
+            19: this._changes.iconPath.replace("$size", "19"),
+            38: this._changes.iconPath.replace("$size", "38")
+          }
+        });
+      }
+
+      if ("badgeText" in this._changes)
       {
         chrome.browserAction.setBadgeText({
           tabId: this._tabId,
-          text: ""
+          text: this._changes.badgeText
         });
-        return;
-      }
-
-      if ("color" in badge)
+      }
+
+      if ("badgeColor" in this._changes)
       {
         chrome.browserAction.setBadgeBackgroundColor({
           tabId: this._tabId,
-          color: badge.color
+          color: this._changes.badgeColor
         });
       }
 
-      if ("number" in badge)
-      {
-        chrome.browserAction.setBadgeText({
-          tabId: this._tabId,
-          text: badge.number.toString()
-        });
+      this._changes = null;
+    },
+    _queueChanges: function()
+    {
+      chrome.tabs.get(this._tabId, function()
+      {
+        // If the tab is prerendered, chrome.tabs.get() sets
+        // chrome.runtime.lastError and we have to delay our changes
+        // until the currently visible tab is replaced with the
+        // prerendered tab. Otherwise chrome.browserAction.set* fails.
+        if (chrome.runtime.lastError)
+        {
+          var onReplaced = function(addedTabId, removedTabId)
+          {
+            if (addedTabId == this._tabId)
+            {
+              chrome.tabs.onReplaced.removeListener(onReplaced);
+              this._applyChanges();
+            }
+          }.bind(this);
+          chrome.tabs.onReplaced.addListener(onReplaced);
+        }
+        else
+        {
+          this._applyChanges();
+        }
+      }.bind(this));
+    },
+    _addChange: function(name, value)
+    {
+      if (!this._changes)
+      {
+        this._changes = {};
+        this._queueChanges();
+      }
+
+      this._changes[name] = value;
+    },
+    setIcon: function(path)
+    {
+      this._addChange("iconPath", path);
+    },
+    setBadge: function(badge)
+    {
+      if (!badge)
+      {
+        this._addChange("badgeText", "");
+      }
+      else
+      {
+        if ("number" in badge)
+          this._addChange("badgeText", badge.number.toString());
+
+        if ("color" in badge)
+          this._addChange("badgeColor", badge.color);
       }
     }
   };
 
 
   /* Context menus */
 
   var contextMenuItems = new ext.PageMap();
   var contextMenuUpdating = false;
 
@@ skipping 58 matching lines @@
 
   chrome.windows.onFocusChanged.addListener(function(windowId)
   {
     if (windowId != chrome.windows.WINDOW_ID_NONE)
       updateContextMenu();
   });
 
 
   /* Web requests */
 
-  var framesOfTabs = {__proto__: null};
+  var framesOfTabs = Object.create(null);
 
   ext.getFrame = function(tabId, frameId)
   {
     return (framesOfTabs[tabId] || {})[frameId];
   };
 
   ext.webRequest = {
     onBeforeRequest: new ext._EventTarget(),
     handlerBehaviorChanged: chrome.webRequest.handlerBehaviorChanged
   };
 
   chrome.tabs.query({}, function(tabs)
   {
     tabs.forEach(function(tab)
     {
       chrome.webNavigation.getAllFrames({tabId: tab.id}, function(details)
       {
         if (details && details.length > 0)
         {
-          var frames = framesOfTabs[tab.id] = {__proto__: null};
+          var frames = framesOfTabs[tab.id] = Object.create(null);
 
           for (var i = 0; i < details.length; i++)
             frames[details[i].frameId] = {url: new URL(details[i].url), parent: null};
 
           for (var i = 0; i < details.length; i++)
           {
             var parentFrameId = details[i].parentFrameId;
 
             if (parentFrameId != -1)
               frames[details[i].frameId].parent = frames[parentFrameId];
@@ skipping 19 matching lines @@
         // assume that the first request belongs to the top frame. Chrome
         // may give the top frame the type "object" instead of "main_frame".
         // https://code.google.com/p/chromium/issues/detail?id=281711
         details.frameId == 0 && !(details.tabId in framesOfTabs)
       );
 
       var frames = null;
       if (!isMainFrame)
         frames = framesOfTabs[details.tabId];
       if (!frames)
-        frames = framesOfTabs[details.tabId] = {__proto__: null};
+        frames = framesOfTabs[details.tabId] = Object.create(null);
 
       var frame = null;
       var url = new URL(details.url);
       if (!isMainFrame)
       {
         // we are looking for the frame that contains the element that
         // is about to load, however if a frame is loading the surrounding
         // frame is indicated by parentFrameId instead of frameId
         var frameId;
         if (requestType == "sub_frame")
@@ skipping 69 matching lines @@
           }
 
           return frames[0];
         }
       }
     };
 
     return ext.onMessage._dispatch(message, sender, sendResponse).indexOf(true) != -1;
   });
 
+  // We have to ensure there is at least one listener for the onConnect event.
+  // Otherwise we can't connect a port later, which we need to do in order to
+  // detect when the extension is reloaded, disabled or uninstalled.
+  chrome.runtime.onConnect.addListener(function() {});
+
 
   /* Storage */
 
   ext.storage = localStorage;
 
 
   /* Options */
 
   ext.showOptions = function(callback)
   {
@@ skipping 27 matching lines @@
             callback(new Page(tab));
         }
         else
         {
           ext.pages.open(optionsUrl, callback);
         }
       });
     });
   };
 })();