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 */
   ext.windows = {
     create(createData, callback)
     {
       chrome.windows.create(createData, createdWindow =>
       {
         afterTabLoaded(callback)(createdWindow.tabs[0]);
       });
     }
   };
 }());