Bug 1801471 - Handle Private Browsing mode in unified extensions panel. r=rpl

Differential Revision: https://phabricator.services.mozilla.com/D162541

browser/base/content/browser-addons.js

@@ -1325,13 +1325,21 @@ var gUnifiedExtensions = {
     // We only want to display active and visible extensions that do not have a
     // browser action, and we want to list them alphabetically.
     let addons = await AddonManager.getAddonsByTypes(["extension"]);
-    addons = addons.filter(
-      addon =>
-        !addon.hidden &&
-        addon.isActive &&
-        (all ||
-          !WebExtensionPolicy.getByID(addon.id).extension.hasBrowserActionUI)
-    );
+    addons = addons.filter(addon => {
+      if (addon.hidden || !addon.isActive) {
+        return false;
+      }
+
+      const extension = WebExtensionPolicy.getByID(addon.id)?.extension;
+      // Ignore extensions that cannot access the current window (e.g.
+      // extensions not allowed in PB mode when we are in a private window)
+      // since users cannot do anything with those extensions anyway.
+      if (!extension?.canAccessWindow(window)) {
+        return false;
+      }
+
+      return all || !extension?.hasBrowserActionUI;
+    });
     addons.sort((a1, a2) => a1.name.localeCompare(a2.name));
 
     return addons;

browser/components/extensions/test/browser/browser_ext_browserAction_incognito.js

@@ -5,7 +5,9 @@
 async function testIncognito(incognitoOverride) {
   let extension = ExtensionTestUtils.loadExtension({
     manifest: {
-      browser_action: {},
+      browser_action: {
+        default_area: "navbar",
+      },
     },
     incognitoOverride,
   });

browser/components/extensions/test/browser/browser_unified_extensions.js

@@ -328,7 +328,20 @@ add_task(async function test_list_active_extensions_only() {
     // We have to use the mock provider below so we don't need to use the
     // `addonManager` here.
     useAddonManager: false,
+    // Allow all extensions in PB mode by default.
+    incognitoOverride: "spanning",
   });
+  // This extension is loaded with a different `incognitoOverride` value to
+  // make sure it won't show up in a private window.
+  extensions.push(
+    ExtensionTestUtils.loadExtension({
+      manifest: {
+        name: "regular addon with private browsing disabled",
+      },
+      useAddonManager: false,
+      incognitoOverride: "not_allowed",
+    })
+  );
 
   await Promise.all(extensions.map(extension => extension.startup()));
 
@@ -380,41 +393,87 @@ add_task(async function test_list_active_extensions_only() {
       version: "1",
       hidden: arrayOfManifestData[5].hidden,
     },
+    {
+      id: extensions[6].id,
+      name: "regular addon with private browsing disabled",
+      type: "extension",
+      version: "1",
+      hidden: false,
+    },
   ]);
 
-  await openExtensionsPanel(win);
+  for (const isPrivate of [false, true]) {
+    info(
+      `verifying extensions listed in the panel with private browsing ${
+        isPrivate ? "enabled" : "disabled"
+      }`
+    );
+    const aWin = await promiseEnableUnifiedExtensions({ private: isPrivate });
 
-  const hiddenAddonItem = getUnifiedExtensionsItem(win, extensions[0].id);
-  is(hiddenAddonItem, null, `didn't expect an item for ${extensions[0].id}`);
+    await openExtensionsPanel(aWin);
 
-  const regularAddonItem = getUnifiedExtensionsItem(win, extensions[1].id);
-  is(
-    regularAddonItem.querySelector(".unified-extensions-item-name").textContent,
-    "regular addon",
-    "expected an item for a regular add-on"
-  );
+    const hiddenAddonItem = getUnifiedExtensionsItem(aWin, extensions[0].id);
+    is(hiddenAddonItem, null, "didn't expect an item for a hidden add-on");
 
-  const disabledAddonItem = getUnifiedExtensionsItem(win, extensions[2].id);
-  is(disabledAddonItem, null, `didn't expect an item for ${extensions[2].id}`);
+    const regularAddonItem = getUnifiedExtensionsItem(aWin, extensions[1].id);
+    is(
+      regularAddonItem.querySelector(".unified-extensions-item-name")
+        .textContent,
+      "regular addon",
+      "expected an item for a regular add-on"
+    );
 
-  const browserActionItem = getUnifiedExtensionsItem(win, extensions[3].id);
-  is(browserActionItem, null, `didn't expect an item for ${extensions[3].id}`);
+    const disabledAddonItem = getUnifiedExtensionsItem(aWin, extensions[2].id);
+    is(disabledAddonItem, null, "didn't expect an item for a disabled add-on");
 
-  const mv3BrowserActionItem = getUnifiedExtensionsItem(win, extensions[4].id);
-  is(
-    mv3BrowserActionItem,
-    null,
-    `didn't expect an item for ${extensions[4].id}`
-  );
+    const browserActionItem = getUnifiedExtensionsItem(aWin, extensions[3].id);
+    is(
+      browserActionItem,
+      null,
+      "didn't expect an item for an add-on with browser action placed in the navbar"
+    );
 
-  const pageActionItem = getUnifiedExtensionsItem(win, extensions[5].id);
-  is(
-    pageActionItem.querySelector(".unified-extensions-item-name").textContent,
-    "regular addon with page action",
-    "expected an item for a regular add-on with page action"
-  );
+    const mv3BrowserActionItem = getUnifiedExtensionsItem(
+      aWin,
+      extensions[4].id
+    );
+    is(
+      mv3BrowserActionItem,
+      null,
+      "didn't expect an item for a MV3 add-on with browser action placed in the navbar"
+    );
 
-  await closeExtensionsPanel(win);
+    const pageActionItem = getUnifiedExtensionsItem(aWin, extensions[5].id);
+    is(
+      pageActionItem.querySelector(".unified-extensions-item-name").textContent,
+      "regular addon with page action",
+      "expected an item for a regular add-on with page action"
+    );
+
+    const privateBrowsingDisabledItem = getUnifiedExtensionsItem(
+      aWin,
+      extensions[6].id
+    );
+    if (isPrivate) {
+      is(
+        privateBrowsingDisabledItem,
+        null,
+        "didn't expect an item for a regular add-on with private browsing enabled"
+      );
+    } else {
+      is(
+        privateBrowsingDisabledItem.querySelector(
+          ".unified-extensions-item-name"
+        ).textContent,
+        "regular addon with private browsing disabled",
+        "expected an item for a regular add-on with private browsing disabled"
+      );
+    }
+
+    await closeExtensionsPanel(aWin);
+
+    await BrowserTestUtils.closeWindow(aWin);
+  }
 
   await Promise.all(extensions.map(extension => extension.unload()));
   mockProvider.unregister();

browser/components/extensions/test/browser/head_unified_extensions.js

@@ -13,12 +13,12 @@
             promiseEnableUnifiedExtensions
 */
 
-const promiseEnableUnifiedExtensions = async () => {
+const promiseEnableUnifiedExtensions = async (options = {}) => {
   await SpecialPowers.pushPrefEnv({
     set: [["extensions.unifiedExtensions.enabled", true]],
   });
 
-  return BrowserTestUtils.openNewBrowserWindow();
+  return BrowserTestUtils.openNewBrowserWindow(options);
 };
 
 const promiseDisableUnifiedExtensions = async () => {
@@ -127,7 +127,7 @@ const clickUnifiedExtensionsItem = async (
 let extensionsCreated = 0;
 const createExtensions = (
   arrayOfManifestData,
-  { useAddonManager = true } = {}
+  { useAddonManager = true, incognitoOverride } = {}
 ) => {
   return arrayOfManifestData.map(manifestData =>
     ExtensionTestUtils.loadExtension({
@@ -139,6 +139,7 @@ const createExtensions = (
         ...manifestData,
       },
       useAddonManager: useAddonManager ? "temporary" : undefined,
+      incognitoOverride,
     })
   );
 };