1 files changed, 302 insertions, 0 deletions
diff --git a/toolkit/components/extensions/test/xpcshell/test_ext_incognito.js b/toolkit/components/extensions/test/xpcshell/test_ext_incognito.js
new file mode 100644
index 0000000000..9b17a633e9
--- /dev/null
+++ b/toolkit/components/extensions/test/xpcshell/test_ext_incognito.js
@@ -0,0 +1,302 @@
+/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim: set sts=2 sw=2 et tw=80: */
+"use strict";
+
+const { AddonManager } = ChromeUtils.import(
+  "resource://gre/modules/AddonManager.jsm"
+);
+
+AddonTestUtils.init(this);
+AddonTestUtils.overrideCertDB();
+AddonTestUtils.createAppInfo(
+  "xpcshell@tests.mozilla.org",
+  "XPCShell",
+  "1",
+  "42"
+);
+AddonTestUtils.usePrivilegedSignatures = id => id.startsWith("privileged");
+
+// Assert on the expected "addonsManager.action" telemetry events (and optional filter events to verify
+// by using a given actionType).
+function assertActionAMTelemetryEvent(
+  expectedActionEvents,
+  assertMessage,
+  { actionType } = {}
+) {
+  const snapshot = Services.telemetry.snapshotEvents(
+    Ci.nsITelemetry.DATASET_PRERELEASE_CHANNELS,
+    true
+  );
+
+  ok(
+    snapshot.parent && !!snapshot.parent.length,
+    "Got parent telemetry events in the snapshot"
+  );
+
+  const events = snapshot.parent
+    .filter(([timestamp, category, method, object, value, extra]) => {
+      return (
+        category === "addonsManager" &&
+        method === "action" &&
+        (!actionType ? true : extra && extra.action === actionType)
+      );
+    })
+    .map(([timestamp, category, method, object, value, extra]) => {
+      return { method, object, value, extra };
+    });
+
+  Assert.deepEqual(events, expectedActionEvents, assertMessage);
+}
+
+async function runIncognitoTest(
+  extensionData,
+  privateBrowsingAllowed,
+  allowPrivateBrowsingByDefault
+) {
+  Services.prefs.setBoolPref(
+    "extensions.allowPrivateBrowsingByDefault",
+    allowPrivateBrowsingByDefault
+  );
+
+  let wrapper = ExtensionTestUtils.loadExtension(extensionData);
+  await wrapper.startup();
+  let { extension } = wrapper;
+
+  if (!allowPrivateBrowsingByDefault) {
+    // Check the permission if we're not allowPrivateBrowsingByDefault.
+    equal(
+      extension.permissions.has("internal:privateBrowsingAllowed"),
+      privateBrowsingAllowed,
+      "privateBrowsingAllowed in serialized extension"
+    );
+  }
+  equal(
+    extension.privateBrowsingAllowed,
+    privateBrowsingAllowed,
+    "privateBrowsingAllowed in extension"
+  );
+  equal(
+    extension.policy.privateBrowsingAllowed,
+    privateBrowsingAllowed,
+    "privateBrowsingAllowed on policy"
+  );
+
+  await wrapper.unload();
+  Services.prefs.clearUserPref("extensions.allowPrivateBrowsingByDefault");
+}
+
+add_task(async function test_extension_incognito_spanning() {
+  await runIncognitoTest({}, false, false);
+  await runIncognitoTest({}, true, true);
+});
+
+// Test that when we are restricted, we can override the restriction for tests.
+add_task(async function test_extension_incognito_override_spanning() {
+  let extensionData = {
+    incognitoOverride: "spanning",
+  };
+  await runIncognitoTest(extensionData, true, false);
+});
+
+// This tests that a privileged extension will always have private browsing.
+add_task(async function test_extension_incognito_privileged() {
+  let extensionData = {
+    isPrivileged: true,
+  };
+  await runIncognitoTest(extensionData, true, true);
+  await runIncognitoTest(extensionData, true, false);
+});
+
+// We only test spanning upgrades since that is the only allowed
+// incognito type prior to feature being turned on.
+add_task(async function test_extension_incognito_spanning_grandfathered() {
+  await AddonTestUtils.promiseStartupManager();
+  Services.prefs.setBoolPref("extensions.allowPrivateBrowsingByDefault", true);
+  Services.prefs.setBoolPref("extensions.incognito.migrated", false);
+
+  // This extension gets disabled before the "upgrade", it should not
+  // get grandfathered permissions.
+  const disabledAddonId = "disabled-ext@mozilla.com";
+  let disabledWrapper = ExtensionTestUtils.loadExtension({
+    manifest: {
+      applications: { gecko: { id: disabledAddonId } },
+      incognito: "spanning",
+    },
+    useAddonManager: "permanent",
+  });
+  await disabledWrapper.startup();
+  let disabledPolicy = WebExtensionPolicy.getByID(disabledAddonId);
+
+  // Verify policy settings.
+  equal(
+    disabledPolicy.permissions.includes("internal:privateBrowsingAllowed"),
+    false,
+    "privateBrowsingAllowed is not in permissions for disabled addon"
+  );
+  equal(
+    disabledPolicy.privateBrowsingAllowed,
+    true,
+    "privateBrowsingAllowed in disabled addon"
+  );
+
+  let disabledAddon = await AddonManager.getAddonByID(disabledAddonId);
+  await disabledAddon.disable();
+
+  // This extension gets grandfathered permissions for private browsing.
+  let addonId = "grandfathered@mozilla.com";
+  let wrapper = ExtensionTestUtils.loadExtension({
+    manifest: {
+      applications: { gecko: { id: addonId } },
+      incognito: "spanning",
+    },
+    useAddonManager: "permanent",
+  });
+  await wrapper.startup();
+  let policy = WebExtensionPolicy.getByID(addonId);
+
+  // Verify policy settings.
+  equal(
+    policy.permissions.includes("internal:privateBrowsingAllowed"),
+    false,
+    "privateBrowsingAllowed is not in permissions"
+  );
+  equal(
+    policy.privateBrowsingAllowed,
+    true,
+    "privateBrowsingAllowed in extension"
+  );
+
+  // Turn on incognito support and update the browser.
+  Services.prefs.setBoolPref("extensions.allowPrivateBrowsingByDefault", false);
+  // Disable the addonsManager telemetry event category, to ensure that it will
+  // be enabled automatically during the AddonManager/XPIProvider startup and
+  // the telemetry event recorded (See Bug 1540112 for a rationale).
+  Services.telemetry.setEventRecordingEnabled("addonsManager", false);
+  await AddonTestUtils.promiseRestartManager("2");
+  await wrapper.awaitStartup();
+
+  // Did it upgrade?
+  ok(
+    Services.prefs.getBoolPref("extensions.incognito.migrated", false),
+    "pref marked as migrated"
+  );
+
+  // Verify policy settings.
+  policy = WebExtensionPolicy.getByID(addonId);
+  ok(
+    policy.permissions.includes("internal:privateBrowsingAllowed"),
+    "privateBrowsingAllowed is in permissions"
+  );
+  equal(
+    policy.privateBrowsingAllowed,
+    true,
+    "privateBrowsingAllowed in extension"
+  );
+
+  // Verify the disabled addon did not get permissions.
+  disabledAddon = await AddonManager.getAddonByID(disabledAddonId);
+  await disabledAddon.enable();
+  disabledPolicy = WebExtensionPolicy.getByID(disabledAddonId);
+
+  // Verify policy settings.
+  equal(
+    disabledPolicy.permissions.includes("internal:privateBrowsingAllowed"),
+    false,
+    "privateBrowsingAllowed is not in permissions for disabled addon"
+  );
+  equal(
+    disabledPolicy.privateBrowsingAllowed,
+    false,
+    "privateBrowsingAllowed in disabled addon"
+  );
+
+  await wrapper.unload();
+  await disabledWrapper.unload();
+  Services.prefs.clearUserPref("extensions.allowPrivateBrowsingByDefault");
+  Services.prefs.clearUserPref("extensions.incognito.migrated");
+
+  const expectedEvents = [
+    {
+      method: "action",
+      object: "appUpgrade",
+      value: "on",
+      extra: { addonId, action: "privateBrowsingAllowed" },
+    },
+  ];
+
+  assertActionAMTelemetryEvent(
+    expectedEvents,
+    "Got the expected telemetry events for the grandfathered extensions",
+    { actionType: "privateBrowsingAllowed" }
+  );
+});
+
+add_task(async function test_extension_privileged_not_allowed() {
+  Services.prefs.setBoolPref("extensions.allowPrivateBrowsingByDefault", false);
+
+  let addonId = "privileged_not_allowed@mochi.test";
+  let extensionData = {
+    manifest: {
+      version: "1.0",
+      applications: { gecko: { id: addonId } },
+      incognito: "not_allowed",
+    },
+    useAddonManager: "permanent",
+    isPrivileged: true,
+  };
+  let wrapper = ExtensionTestUtils.loadExtension(extensionData);
+  await wrapper.startup();
+  let policy = WebExtensionPolicy.getByID(addonId);
+  equal(
+    policy.extension.isPrivileged,
+    true,
+    "The test extension is privileged"
+  );
+  equal(
+    policy.privateBrowsingAllowed,
+    false,
+    "privateBrowsingAllowed is false"
+  );
+
+  await wrapper.unload();
+});
+
+// Test that we remove pb permission if an extension is updated to not_allowed.
+add_task(async function test_extension_upgrade_not_allowed() {
+  Services.prefs.setBoolPref("extensions.allowPrivateBrowsingByDefault", false);
+
+  let addonId = "upgrade@mochi.test";
+  let extensionData = {
+    manifest: {
+      version: "1.0",
+      applications: { gecko: { id: addonId } },
+      incognito: "spanning",
+    },
+    useAddonManager: "permanent",
+    incognitoOverride: "spanning",
+  };
+  let wrapper = ExtensionTestUtils.loadExtension(extensionData);
+  await wrapper.startup();
+
+  let policy = WebExtensionPolicy.getByID(addonId);
+
+  equal(
+    policy.privateBrowsingAllowed,
+    true,
+    "privateBrowsingAllowed in extension"
+  );
+
+  extensionData.manifest.version = "2.0";
+  extensionData.manifest.incognito = "not_allowed";
+  await wrapper.upgrade(extensionData);
+
+  equal(wrapper.version, "2.0", "Expected extension version");
+  policy = WebExtensionPolicy.getByID(addonId);
+  equal(
+    policy.privateBrowsingAllowed,
+    false,
+    "privateBrowsingAllowed is false"
+  );
+
+  await wrapper.unload();
+});