Issue 3138 - Improve how context menu "block element" handles iframes

ext/background.js

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
- * Copyright (C) 2006-2017 eyeo GmbH
+ * Copyright (C) 2006-present 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/>.
  */
 
 "use strict";
 
-(function()
 {
   let nonEmptyPageMaps = new Set();
 
   let PageMap = ext.PageMap = function()
   {
     this._map = new Map();
   };
   PageMap.prototype = {
     _delete(id)
     {
@@ skipping 63 matching lines @@
         let frame = frames.get(0);
         if (frame)
           return frame.url;
       }
     },
     sendMessage(message, responseCallback, frameId)
     {
       let options = {};
       if (typeof frameId != "undefined")
         options.frameId = frameId;
-      chrome.tabs.sendMessage(this.id, message, options, responseCallback);
+      browser.tabs.sendMessage(this.id, message, options, responseCallback);
     }
   };
 
   ext.getPage = id => new Page({id: parseInt(id, 10)});
 
   function afterTabLoaded(callback)
   {
     return openedTab =>
     {
       let onUpdated = (tabId, changeInfo, tab) =>
       {
         if (tabId == openedTab.id && changeInfo.status == "complete")
         {
-          chrome.tabs.onUpdated.removeListener(onUpdated);
+          browser.tabs.onUpdated.removeListener(onUpdated);
           callback(new Page(openedTab));
         }
       };
-      chrome.tabs.onUpdated.addListener(onUpdated);
+      browser.tabs.onUpdated.addListener(onUpdated);
     };
   }
 
   ext.pages = {
-    open(url, callback)
-    {
-      chrome.tabs.create({url}, callback && afterTabLoaded(callback));
-    },
-    query(info, callback)
-    {
-      let rawInfo = {};
-      for (let property in info)
-      {
-        switch (property)
-        {
-          case "active":
-          case "lastFocusedWindow":
-            rawInfo[property] = info[property];
-        }
-      }
-
-      chrome.tabs.query(rawInfo, tabs =>
-      {
-        callback(tabs.map(tab => new Page(tab)));
-      });
-    },
     onLoading: new ext._EventTarget(),
     onActivated: new ext._EventTarget(),
     onRemoved: new ext._EventTarget()
   };
 
-  chrome.tabs.onUpdated.addListener((tabId, changeInfo, tab) =>
+  browser.tabs.onUpdated.addListener((tabId, changeInfo, tab) =>
   {
     if (changeInfo.status == "loading")
       ext.pages.onLoading._dispatch(new Page(tab));
   });
 
   function createFrame(tabId, frameId)
   {
     let frames = framesOfTabs.get(tabId);
     if (!frames)
     {
@@ skipping 12 matching lines @@
   }
 
   function updatePageFrameStructure(frameId, tabId, url, parentFrameId)
   {
     if (frameId == 0)
     {
       let page = new Page({id: tabId, url});
 
       ext._removeFromAllPageMaps(tabId);
 
-      chrome.tabs.get(tabId, () =>
-      {
-        // 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)
+      browser.tabs.get(tabId, () =>
+      {
+        // If the tab is prerendered, browser.tabs.get() sets
+        // browser.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 onUpdated event for
+        // tabs that are already visible. Otherwise browser action changes get
+        // overridden when Chrome automatically resets them on navigation.
+        if (browser.runtime.lastError)
           ext.pages.onLoading._dispatch(page);
       });
     }
 
     // Update frame URL and parent in frame structure
     let frame = createFrame(tabId, frameId);
     frame.url = new URL(url);
 
     let parentFrame = framesOfTabs.get(tabId).get(parentFrameId);
     if (parentFrame)
       frame.parent = parentFrame;
   }
 
-  chrome.webRequest.onHeadersReceived.addListener(details =>
+  browser.webRequest.onHeadersReceived.addListener(details =>
   {
     // We have to update the frame structure when switching to a new
     // document, so that we process any further requests made by that
     // document in the right context. Unfortunately, we cannot rely
     // on webNavigation.onCommitted since it isn't guaranteed to fire
     // before any subresources start downloading[1]. As an
     // alternative we use webRequest.onHeadersReceived for HTTP(S)
     // URLs, being careful to ignore any responses that won't cause
     // the document to be replaced.
     // [1] - https://bugs.chromium.org/p/chromium/issues/detail?id=665843
@@ skipping 57 matching lines @@
           return;
       }
     }
 
     updatePageFrameStructure(details.frameId, details.tabId, details.url,
                              details.parentFrameId);
   },
   {types: ["main_frame", "sub_frame"], urls: ["http://*/*", "https://*/*"]},
   ["responseHeaders"]);
 
-  chrome.webNavigation.onBeforeNavigate.addListener(details =>
+  browser.webNavigation.onBeforeNavigate.addListener(details =>
   {
     // Since we can only listen for HTTP(S) responses using
     // webRequest.onHeadersReceived we must update the page structure here for
     // other navigations.
     let url = new URL(details.url);
     if (url.protocol != "http:" && url.protocol != "https:")
     {
       updatePageFrameStructure(details.frameId, details.tabId, details.url,
                                details.parentFrameId);
     }
   });
 
   function forgetTab(tabId)
   {
     ext.pages.onRemoved._dispatch(tabId);
 
     ext._removeFromAllPageMaps(tabId);
     framesOfTabs.delete(tabId);
   }
 
-  chrome.tabs.onReplaced.addListener((addedTabId, removedTabId) =>
+  browser.tabs.onReplaced.addListener((addedTabId, removedTabId) =>
   {
     forgetTab(removedTabId);
   });
 
-  chrome.tabs.onRemoved.addListener(forgetTab);
-
-  chrome.tabs.onActivated.addListener(details =>
+  browser.tabs.onRemoved.addListener(forgetTab);
+
+  browser.tabs.onActivated.addListener(details =>
   {
     ext.pages.onActivated._dispatch(new Page({id: details.tabId}));
   });
 
 
   /* Browser actions */
 
   let BrowserAction = function(tabId)
   {
     this._tabId = tabId;
     this._changes = null;
   };
   BrowserAction.prototype = {
     _applyChanges()
     {
       if ("iconPath" in this._changes)
       {
-        chrome.browserAction.setIcon({
-          tabId: this._tabId,
-          path: {
+        // Firefox for Android displays the browser action not as an icon but
+        // as a menu item. There is no icon, but such an option may be added in
+        // the future.
+        // https://bugzilla.mozilla.org/show_bug.cgi?id=1331746
+        if ("setIcon" in browser.browserAction)
+        {
+          let path = {
             16: this._changes.iconPath.replace("$size", "16"),
             19: this._changes.iconPath.replace("$size", "19"),
             20: this._changes.iconPath.replace("$size", "20"),
             32: this._changes.iconPath.replace("$size", "32"),
             38: this._changes.iconPath.replace("$size", "38"),
             40: this._changes.iconPath.replace("$size", "40")
+          };
+          try
+          {
+            browser.browserAction.setIcon({tabId: this._tabId, path});
           }
-        });
+          catch (e)
+          {
+            // Edge throws if passed icon sizes different than 19,20,38,40px.
+            delete path[16];
+            delete path[32];
+            browser.browserAction.setIcon({tabId: this._tabId, path});
+          }
+        }
       }
 
       if ("badgeText" in this._changes)
       {
-        chrome.browserAction.setBadgeText({
-          tabId: this._tabId,
-          text: this._changes.badgeText
-        });
+        // There is no badge on Firefox for Android; the browser action is
+        // simply a menu item.
+        if ("setBadgeText" in browser.browserAction)
+        {
+          browser.browserAction.setBadgeText({
+            tabId: this._tabId,
+            text: this._changes.badgeText
+          });
+        }
       }
 
       if ("badgeColor" in this._changes)
       {
-        chrome.browserAction.setBadgeBackgroundColor({
-          tabId: this._tabId,
-          color: this._changes.badgeColor
-        });
+        // There is no badge on Firefox for Android; the browser action is
+        // simply a menu item.
+        if ("setBadgeBackgroundColor" in browser.browserAction)
+        {
+          browser.browserAction.setBadgeBackgroundColor({
+            tabId: this._tabId,
+            color: this._changes.badgeColor
+          });
+        }
       }
 
       this._changes = null;
     },
     _queueChanges()
     {
-      chrome.tabs.get(this._tabId, () =>
-      {
-        // If the tab is prerendered, chrome.tabs.get() sets
-        // chrome.runtime.lastError and we have to delay our changes
+      browser.tabs.get(this._tabId, () =>
+      {
+        // If the tab is prerendered, browser.tabs.get() sets
+        // browser.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)
+        // prerendered tab. Otherwise browser.browserAction.set* fails.
+        if (browser.runtime.lastError)
         {
           let onReplaced = (addedTabId, removedTabId) =>
           {
             if (addedTabId == this._tabId)
             {
-              chrome.tabs.onReplaced.removeListener(onReplaced);
+              browser.tabs.onReplaced.removeListener(onReplaced);
               this._applyChanges();
             }
           };
-          chrome.tabs.onReplaced.addListener(onReplaced);
+          browser.tabs.onReplaced.addListener(onReplaced);
         }
         else
         {
           this._applyChanges();
         }
       });
     },
     _addChange(name, value)
     {
       if (!this._changes)
@@ skipping 26 matching lines @@
   };
 
 
   /* Context menus */
 
   let contextMenuItems = new ext.PageMap();
   let contextMenuUpdating = false;
 
   let updateContextMenu = () =>
   {
-    if (contextMenuUpdating)
+    // Firefox for Android does not support context menus.
+    // https://bugzilla.mozilla.org/show_bug.cgi?id=1269062
+    if (!("contextMenus" in browser) || contextMenuUpdating)
       return;
 
     contextMenuUpdating = true;
 
-    chrome.tabs.query({active: true, lastFocusedWindow: true}, tabs =>
-    {
-      chrome.contextMenus.removeAll(() =>
+    browser.tabs.query({active: true, lastFocusedWindow: true}, tabs =>
+    {
+      browser.contextMenus.removeAll(() =>
       {
         contextMenuUpdating = false;
 
         if (tabs.length == 0)
           return;
 
         let items = contextMenuItems.get({id: tabs[0].id});
 
         if (!items)
           return;
 
         items.forEach(item =>
         {
-          chrome.contextMenus.create({
+          browser.contextMenus.create({
             title: item.title,
             contexts: item.contexts,
             onclick(info, tab)
             {
               item.onclick(new Page(tab), info);
             }
           });
         });
       });
     });
@@ skipping 21 matching lines @@
         let index = items.indexOf(item);
         if (index != -1)
         {
           items.splice(index, 1);
           updateContextMenu();
         }
       }
     }
   };
 
-  chrome.tabs.onActivated.addListener(updateContextMenu);
-
-  chrome.windows.onFocusChanged.addListener(windowId =>
-  {
-    if (windowId != chrome.windows.WINDOW_ID_NONE)
-      updateContextMenu();
-  });
+  browser.tabs.onActivated.addListener(updateContextMenu);
+
+  if ("windows" in browser)
+  {
+    browser.windows.onFocusChanged.addListener(windowId =>
+    {
+      if (windowId != browser.windows.WINDOW_ID_NONE)
+        updateContextMenu();
+    });
+  }
 
 
   /* Web requests */
 
   let framesOfTabs = new Map();
 
   ext.getFrame = (tabId, frameId) =>
   {
     let frames = framesOfTabs.get(tabId);
     return frames && frames.get(frameId);
   };
 
   let handlerBehaviorChangedQuota =
-    chrome.webRequest.MAX_HANDLER_BEHAVIOR_CHANGED_CALLS_PER_10_MINUTES;
+    browser.webRequest.MAX_HANDLER_BEHAVIOR_CHANGED_CALLS_PER_10_MINUTES;
 
   function propagateHandlerBehaviorChange()
   {
     // Make sure to not call handlerBehaviorChanged() more often than allowed
-    // by chrome.webRequest.MAX_HANDLER_BEHAVIOR_CHANGED_CALLS_PER_10_MINUTES.
+    // by browser.webRequest.MAX_HANDLER_BEHAVIOR_CHANGED_CALLS_PER_10_MINUTES.
     // Otherwise Chrome notifies the user that this extension is causing issues.
     if (handlerBehaviorChangedQuota > 0)
     {
-      chrome.webNavigation.onBeforeNavigate.removeListener(
+      browser.webNavigation.onBeforeNavigate.removeListener(
         propagateHandlerBehaviorChange
       );
-      chrome.webRequest.handlerBehaviorChanged();
+      browser.webRequest.handlerBehaviorChanged();
 
       handlerBehaviorChangedQuota--;
       setTimeout(() => { handlerBehaviorChangedQuota++; }, 600000);
     }
   }
 
   ext.webRequest = {
     onBeforeRequest: new ext._EventTarget(),
     handlerBehaviorChanged()
     {
       // Defer handlerBehaviorChanged() until navigation occurs.
       // There wouldn't be any visible effect when calling it earlier,
       // but it's an expensive operation and that way we avoid to call
       // it multiple times, if multiple filters are added/removed.
-      let {onBeforeNavigate} = chrome.webNavigation;
+      let {onBeforeNavigate} = browser.webNavigation;
       if (!onBeforeNavigate.hasListener(propagateHandlerBehaviorChange))
         onBeforeNavigate.addListener(propagateHandlerBehaviorChange);
     }
   };
 
-  chrome.tabs.query({}, tabs =>
+  browser.tabs.query({}, tabs =>
   {
     tabs.forEach(tab =>
     {
-      chrome.webNavigation.getAllFrames({tabId: tab.id}, details =>
+      browser.webNavigation.getAllFrames({tabId: tab.id}, details =>
       {
         if (details && details.length > 0)
         {
           let frames = new Map();
           framesOfTabs.set(tab.id, frames);
 
           for (let detail of details)
           {
             let frame = {url: new URL(detail.url)};
             frames.set(detail.frameId, frame);
 
             if (detail.parentFrameId != -1)
               frame.parent = frames.get(detail.parentFrameId);
           }
         }
       });
     });
   });
 
-  chrome.webRequest.onBeforeRequest.addListener(details =>
+  browser.webRequest.onBeforeRequest.addListener(details =>
   {
     // The high-level code isn't interested in requests that aren't
     // related to a tab or requests loading a top-level document,
     // those should never be blocked.
     if (details.type == "main_frame")
       return;
 
     // Filter out requests from non web protocols. Ideally, we'd explicitly
     // specify the protocols we are interested in (i.e. http://, https://,
     // ws:// and wss://) with the url patterns, given below, when adding this
@@ skipping 23 matching lines @@
     }
 
     if (ext.webRequest.onBeforeRequest._dispatch(
         url, type, page, frame).includes(false))
       return {cancel: true};
   }, {urls: ["<all_urls>"]}, ["blocking"]);
 
 
   /* Message passing */
 
-  chrome.runtime.onMessage.addListener((message, rawSender, sendResponse) =>
+  browser.runtime.onMessage.addListener((message, rawSender, sendResponse) =>
   {
     let sender = {};
 
     // Add "page" and "frame" if the message was sent by a content script.
     // If sent by popup or the background page itself, there is no "tab".
     if ("tab" in rawSender)
     {
       sender.page = new Page(rawSender.tab);
       sender.frame = {
         id: rawSender.frameId,
@@ skipping 11 matching lines @@
           if (frame)
             return frame.parent || null;
 
           return frames.get(0) || null;
         }
       };
     }
 
     return ext.onMessage._dispatch(
       message, sender, sendResponse
-    ).indexOf(true) != -1;
+    ).includes(true);
   });
 
 
   /* Storage */
 
   ext.storage = {
     get(keys, callback)
     {
-      chrome.storage.local.get(keys, callback);
+      browser.storage.local.get(keys, callback);
     },
     set(key, value, callback)
     {
       let items = {};
       items[key] = value;
-      chrome.storage.local.set(items, callback);
+      browser.storage.local.set(items, callback);
     },
     remove(key, callback)
     {
-      chrome.storage.local.remove(key, callback);
-    },
-    onChanged: chrome.storage.onChanged
-  };
-
-  /* Options */
-
-  if ("openOptionsPage" in chrome.runtime)
-  {
-    ext.showOptions = callback =>
-    {
-      if (!callback)
-      {
-        chrome.runtime.openOptionsPage();
-      }
-      else
-      {
-        chrome.runtime.openOptionsPage(() =>
-        {
-          if (chrome.runtime.lastError)
-            return;
-
-          chrome.tabs.query({active: true, lastFocusedWindow: true}, tabs =>
-          {
-            if (tabs.length > 0)
-            {
-              if (tabs[0].status == "complete")
-                callback(new Page(tabs[0]));
-              else
-                afterTabLoaded(callback)(tabs[0]);
-            }
-          });
-        });
-      }
-    };
-  }
-  else
-  {
-    // Edge does not yet support runtime.openOptionsPage (tested version 38)
-    // and so this workaround needs to stay for now.
-    // We are not using extension.getURL to get the absolute path here
-    // because of the Edge issue:
-    // https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/10276332/
-    ext.showOptions = callback =>
-    {
-      chrome.windows.getLastFocused(win =>
-      {
-        let optionsUrl = "options.html";
-        let queryInfo = {url: optionsUrl};
-
-        // extension pages can't be accessed in incognito windows. In order to
-        // correctly mimic the way in which Chrome opens extension options,
-        // we have to focus the options page in any other window.
-        if (!win.incognito)
-          queryInfo.windowId = win.id;
-
-        chrome.tabs.query(queryInfo, tabs =>
-        {
-          if (tabs.length > 0)
-          {
-            let tab = tabs[0];
-
-            chrome.windows.update(tab.windowId, {focused: true});
-            chrome.tabs.update(tab.id, {active: true});
-
-            if (callback)
-              callback(new Page(tab));
-          }
-          else
-          {
-            ext.pages.open(optionsUrl, callback);
-          }
-        });
-      });
-    };
-  }
+      browser.storage.local.remove(key, callback);
+    },
+    onChanged: browser.storage.onChanged
+  };
 
   /* Windows */
   ext.windows = {
     create(createData, callback)
     {
-      chrome.windows.create(createData, createdWindow =>
+      browser.windows.create(createData, createdWindow =>
       {
         afterTabLoaded(callback)(createdWindow.tabs[0]);
       });
     }
   };
-}());
+}