Issue 5347 - Check for windows API support

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.
  *
@@ skipping 296 matching lines @@
   chrome.tabs.onRemoved.addListener(forgetTab);
 
   chrome.tabs.onActivated.addListener(details =>
   {
     ext.pages.onActivated._dispatch(new Page({id: details.tabId}));
   });
 
 
   /* Browser actions */
 
+  // On Firefox for Android, open the options page directly when the browser
+  // action is clicked.
+  if (!("getPopup" in chrome.browserAction))
+  {
+    chrome.browserAction.onClicked.addListener(() =>
+    {
+      ext.showOptions();
+    });
+  }
+
   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: {
-            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")
-          }
-        });
+        // 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 chrome.browserAction)
+        {
+          chrome.browserAction.setIcon({
+            tabId: this._tabId,
+            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")
+            }
+          });
+        }
       }
 
       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 chrome.browserAction)
+        {
+          chrome.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 chrome.browserAction)
+        {
+          chrome.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
@@ skipping 49 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 chrome) || contextMenuUpdating)
       return;
 
     contextMenuUpdating = true;
 
     chrome.tabs.query({active: true, lastFocusedWindow: true}, tabs =>
     {
       chrome.contextMenus.removeAll(() =>
       {
         contextMenuUpdating = false;
 
@@ skipping 198 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);
     },
     set(key, value, callback)
     {
       let items = {};
       items[key] = value;
       chrome.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 =>
+  ext.showOptions = callback =>
+  {
+    if ("openOptionsPage" in chrome.runtime &&
+        // Firefox for Android does have a runtime.openOptionsPage but it
+        // doesn't do anything.
+        // https://bugzilla.mozilla.org/show_bug.cgi?id=1364945
+        require("info").application != "fennec")
     {
       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 =>
-    {
-      let optionsUrl = "options.html";
-      let queryInfo = {url: optionsUrl};
-
+    }
+    else
+    {
+      // Edge does not yet support runtime.openOptionsPage (tested version 38)
+      // nor does Firefox for Android,
+      // 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/
       let open = 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 && !win.incognito)
           queryInfo.windowId = win.id;
 
         chrome.tabs.query(queryInfo, tabs =>
         {
-          if (tabs.length > 0)
+          if (tabs && tabs.length > 0)
           {
             let tab = tabs[0];
 
             if ("windows" in chrome)
               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);
           }
         });
       };
 
       if ("windows" in chrome)
+      {
         chrome.windows.getLastFocused(open);
+      }
       else
+      {
+        // Firefox for Android does not support the windows API. Since there is
+        // effectively only one window on the mobile browser, there's no need
+        // to bring it into focus.
         open();
-    };
-  }
+      }
+    }
+  };
 
   /* Windows */
-  if ("windows" in chrome)
-  {
-    ext.windows = {

[Sebastian Noack, 2017/08/15 14:40:19]

What is about the code using ext.windows? I suppose it will just fail with a
different error now?

[Manish Jethani, 2017/08/15 16:24:12]

ext.windows is only used from lib/filterComposer.js. Since we're going to
disable the composer on mobile, this shouldn't be a problem.

If any other code wants to use ext.windows in the future, it should check if it
is supported and do the right thing accordingly.

[Sebastian Noack, 2017/08/18 10:25:21]

I guess we can just leave the code here unchanged then, and just disable the
calling code on Android, as we have to anyway. And if ext.windows is used there
it shouldn't matter whether it fails because it doesn't exist or because the
underlying API it wraps doesn't exist.

[Manish Jethani, 2017/08/18 14:09:58]

I just checked and the only way ext.windows can be called on Android is if the
context menu item is actually displayed. We're not going to display it, so I
think it's OK to just remove this check here.

-      create(createData, callback)
-      {
-        chrome.windows.create(createData, createdWindow =>
-        {
-          afterTabLoaded(callback)(createdWindow.tabs[0]);
-        });
-      }
-    };
-  }
+  ext.windows = {
+    create(createData, callback)
+    {
+      chrome.windows.create(createData, createdWindow =>
+      {
+        afterTabLoaded(callback)(createdWindow.tabs[0]);
+      });
+    }
+  };
 }());