Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

6 files changed, 527 insertions, 0 deletions

diff --git a/browser/extensions/search-detection/tests/browser/.eslintrc.js b/browser/extensions/search-detection/tests/browser/.eslintrc.js
new file mode 100644
index 0000000000..e57058ecb1
--- /dev/null
+++ b/browser/extensions/search-detection/tests/browser/.eslintrc.js
@@ -0,0 +1,7 @@
+"use strict";
+
+module.exports = {
+  env: {
+    webextensions: true,
+  },
+};
diff --git a/browser/extensions/search-detection/tests/browser/browser.ini b/browser/extensions/search-detection/tests/browser/browser.ini
new file mode 100644
index 0000000000..1bd22fe386
--- /dev/null
+++ b/browser/extensions/search-detection/tests/browser/browser.ini
@@ -0,0 +1,9 @@
+[DEFAULT]
+support-files =
+  redirect.sjs
+
+[browser_client_side_redirection.js]
+[browser_extension_loaded.js]
+[browser_server_side_redirection.js]
+skip-if =
+  os == "win" && os_version == "6.1" # Skip on Azure - frequent failure
diff --git a/browser/extensions/search-detection/tests/browser/browser_client_side_redirection.js b/browser/extensions/search-detection/tests/browser/browser_client_side_redirection.js
new file mode 100644
index 0000000000..5dad39dba4
--- /dev/null
+++ b/browser/extensions/search-detection/tests/browser/browser_client_side_redirection.js
@@ -0,0 +1,204 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const { AddonTestUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/AddonTestUtils.sys.mjs"
+);
+
+const { TelemetryTestUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/TelemetryTestUtils.sys.mjs"
+);
+
+AddonTestUtils.initMochitest(this);
+
+const TELEMETRY_EVENTS_FILTERS = {
+  category: "addonsSearchDetection",
+  method: "etld_change",
+};
+
+// The search-detection built-in add-on registers dynamic events.
+const TELEMETRY_TEST_UTILS_OPTIONS = { clear: true, process: "dynamic" };
+
+async function testClientSideRedirect({
+  background,
+  permissions,
+  telemetryExpected = false,
+}) {
+  Services.telemetry.clearEvents();
+
+  // Load an extension that does a client-side redirect. We expect this
+  // extension to be reported in a Telemetry event when `telemetryExpected` is
+  // set to `true`.
+  const addonId = "some@addon-id";
+  const addonVersion = "1.2.3";
+
+  let extension = ExtensionTestUtils.loadExtension({
+    manifest: {
+      version: addonVersion,
+      browser_specific_settings: { gecko: { id: addonId } },
+      permissions,
+    },
+    useAddonManager: "temporary",
+    background,
+  });
+
+  await extension.startup();
+  await extension.awaitMessage("ready");
+
+  // Simulate a search (with the test search engine) by navigating to it.
+  await BrowserTestUtils.withNewTab(
+    {
+      gBrowser,
+      url: "https://example.com/search?q=babar",
+    },
+    () => {}
+  );
+
+  await extension.unload();
+
+  TelemetryTestUtils.assertEvents(
+    telemetryExpected
+      ? [
+          {
+            object: "webrequest",
+            value: "extension",
+            extra: {
+              addonId,
+              addonVersion,
+              from: "example.com",
+              to: "mochi.test",
+            },
+          },
+        ]
+      : [],
+    TELEMETRY_EVENTS_FILTERS,
+    TELEMETRY_TEST_UTILS_OPTIONS
+  );
+}
+
+add_setup(async function () {
+  const searchEngineName = "test search engine";
+
+  let searchEngine;
+
+  // This cleanup function has to be registered before the one registered
+  // internally by loadExtension, otherwise it is going to trigger a test
+  // failure (because it will be called too late).
+  registerCleanupFunction(async () => {
+    await searchEngine.unload();
+    ok(
+      !Services.search.getEngineByName(searchEngineName),
+      "test search engine unregistered"
+    );
+  });
+
+  searchEngine = ExtensionTestUtils.loadExtension({
+    manifest: {
+      chrome_settings_overrides: {
+        search_provider: {
+          name: searchEngineName,
+          keyword: "test",
+          search_url: "https://example.com/?q={searchTerms}",
+        },
+      },
+    },
+    // NOTE: the search extension needs to be installed through the
+    // AddonManager to be correctly unregistered when it is uninstalled.
+    useAddonManager: "temporary",
+  });
+
+  await searchEngine.startup();
+  await AddonTestUtils.waitForSearchProviderStartup(searchEngine);
+  ok(
+    Services.search.getEngineByName(searchEngineName),
+    "test search engine registered"
+  );
+});
+
+add_task(function test_onBeforeRequest() {
+  return testClientSideRedirect({
+    background() {
+      browser.webRequest.onBeforeRequest.addListener(
+        () => {
+          return {
+            redirectUrl: "http://mochi.test:8888/",
+          };
+        },
+        { urls: ["*://example.com/*"] },
+        ["blocking"]
+      );
+
+      browser.test.sendMessage("ready");
+    },
+    permissions: ["webRequest", "webRequestBlocking", "*://example.com/*"],
+    telemetryExpected: true,
+  });
+});
+
+add_task(function test_onBeforeRequest_url_not_monitored() {
+  // Here, we load an extension that does a client-side redirect. Because this
+  // extension does not listen to the URL of the search engine registered
+  // above, we don't expect this extension to be reported in a Telemetry event.
+  return testClientSideRedirect({
+    background() {
+      browser.webRequest.onBeforeRequest.addListener(
+        () => {
+          return {
+            redirectUrl: "http://mochi.test:8888/",
+          };
+        },
+        { urls: ["*://google.com/*"] },
+        ["blocking"]
+      );
+
+      browser.test.sendMessage("ready");
+    },
+    permissions: ["webRequest", "webRequestBlocking", "*://google.com/*"],
+    telemetryExpected: false,
+  });
+});
+
+add_task(function test_onHeadersReceived() {
+  return testClientSideRedirect({
+    background() {
+      browser.webRequest.onHeadersReceived.addListener(
+        () => {
+          return {
+            redirectUrl: "http://mochi.test:8888/",
+          };
+        },
+        { urls: ["*://example.com/*"], types: ["main_frame"] },
+        ["blocking"]
+      );
+
+      browser.test.sendMessage("ready");
+    },
+    permissions: ["webRequest", "webRequestBlocking", "*://example.com/*"],
+    telemetryExpected: true,
+  });
+});
+
+add_task(function test_onHeadersReceived_url_not_monitored() {
+  // Here, we load an extension that does a client-side redirect. Because this
+  // extension does not listen to the URL of the search engine registered
+  // above, we don't expect this extension to be reported in a Telemetry event.
+  return testClientSideRedirect({
+    background() {
+      browser.webRequest.onHeadersReceived.addListener(
+        () => {
+          return {
+            redirectUrl: "http://mochi.test:8888/",
+          };
+        },
+        { urls: ["*://google.com/*"], types: ["main_frame"] },
+        ["blocking"]
+      );
+
+      browser.test.sendMessage("ready");
+    },
+    permissions: ["webRequest", "webRequestBlocking", "*://google.com/*"],
+    telemetryExpected: false,
+  });
+});
diff --git a/browser/extensions/search-detection/tests/browser/browser_extension_loaded.js b/browser/extensions/search-detection/tests/browser/browser_extension_loaded.js
new file mode 100644
index 0000000000..65f6ed09a8
--- /dev/null
+++ b/browser/extensions/search-detection/tests/browser/browser_extension_loaded.js
@@ -0,0 +1,15 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+add_task(async function test_searchDetection_isActive() {
+  let addon = await AddonManager.getAddonByID(
+    "addons-search-detection@mozilla.com"
+  );
+
+  ok(addon, "Add-on exists");
+  ok(addon.isActive, "Add-on is active");
+  ok(addon.isBuiltin, "Add-on is built-in");
+  ok(addon.hidden, "Add-on is hidden");
+});
diff --git a/browser/extensions/search-detection/tests/browser/browser_server_side_redirection.js b/browser/extensions/search-detection/tests/browser/browser_server_side_redirection.js
new file mode 100644
index 0000000000..ea235406a4
--- /dev/null
+++ b/browser/extensions/search-detection/tests/browser/browser_server_side_redirection.js
@@ -0,0 +1,260 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const { AddonTestUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/AddonTestUtils.sys.mjs"
+);
+
+const { TelemetryTestUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/TelemetryTestUtils.sys.mjs"
+);
+
+AddonTestUtils.initMochitest(this);
+
+const TELEMETRY_EVENTS_FILTERS = {
+  category: "addonsSearchDetection",
+  method: "etld_change",
+};
+
+// The search-detection built-in add-on registers dynamic events.
+const TELEMETRY_TEST_UTILS_OPTIONS = { clear: true, process: "dynamic" };
+
+const REDIRECT_SJS =
+  "browser/browser/extensions/search-detection/tests/browser/redirect.sjs?q={searchTerms}";
+// This URL will redirect to `example.net`, which is different than
+// `*.example.com`. That will be the final URL of a redirect chain:
+// www.example.com -> example.net
+const SEARCH_URL_WWW = `https://www.example.com/${REDIRECT_SJS}`;
+// This URL will redirect to `www.example.com`, which will create a redirect
+// chain with two hops:
+// test2.example.com -> www.example.com -> example.net
+const SEARCH_URL_TEST2 = `https://test2.example.com/${REDIRECT_SJS}`;
+// This URL will redirect to `test2.example.com`, which will create a redirect
+// chain with three hops:
+// test1.example.com -> test2.example.com -> www.example.com -> example.net
+const SEARCH_URL_TEST1 = `https://test1.example.com/${REDIRECT_SJS}`;
+
+const TEST_SEARCH_ENGINE_ADDON_ID = "some@addon-id";
+const TEST_SEARCH_ENGINE_ADDON_VERSION = "4.5.6";
+
+const testServerSideRedirect = async ({
+  searchURL,
+  expectedEvents,
+  tabURL,
+}) => {
+  Services.telemetry.clearEvents();
+
+  const searchEngineName = "test search engine";
+  // Load a default search engine because the add-on we are testing here
+  // monitors the search engines.
+  const searchEngine = ExtensionTestUtils.loadExtension({
+    manifest: {
+      version: TEST_SEARCH_ENGINE_ADDON_VERSION,
+      browser_specific_settings: {
+        gecko: { id: TEST_SEARCH_ENGINE_ADDON_ID },
+      },
+      chrome_settings_overrides: {
+        search_provider: {
+          name: searchEngineName,
+          keyword: "test",
+          search_url: searchURL,
+        },
+      },
+    },
+    useAddonManager: "temporary",
+  });
+
+  await searchEngine.startup();
+  ok(
+    Services.search.getEngineByName(searchEngineName),
+    "test search engine registered"
+  );
+  await AddonTestUtils.waitForSearchProviderStartup(searchEngine);
+
+  // Simulate a search (with the test search engine) by navigating to it.
+  const url = tabURL || searchURL.replace("{searchTerms}", "some terms");
+  await BrowserTestUtils.withNewTab("about:blank", async browser => {
+    // Wait for the tab to be fully loaded.
+    let loaded = BrowserTestUtils.browserLoaded(browser);
+    BrowserTestUtils.loadURIString(browser, url);
+    await loaded;
+  });
+
+  await searchEngine.unload();
+  ok(
+    !Services.search.getEngineByName(searchEngineName),
+    "test search engine unregistered"
+  );
+
+  TelemetryTestUtils.assertEvents(
+    expectedEvents,
+    TELEMETRY_EVENTS_FILTERS,
+    TELEMETRY_TEST_UTILS_OPTIONS
+  );
+};
+
+add_task(function test_redirect_final() {
+  return testServerSideRedirect({
+    // www.example.com -> example.net
+    searchURL: SEARCH_URL_WWW,
+    expectedEvents: [
+      {
+        object: "other",
+        value: "server",
+        extra: {
+          addonId: TEST_SEARCH_ENGINE_ADDON_ID,
+          addonVersion: TEST_SEARCH_ENGINE_ADDON_VERSION,
+          from: "example.com",
+          to: "example.net",
+        },
+      },
+    ],
+  });
+});
+
+add_task(function test_redirect_two_hops() {
+  return testServerSideRedirect({
+    // test2.example.com -> www.example.com -> example.net
+    searchURL: SEARCH_URL_TEST2,
+    expectedEvents: [
+      {
+        object: "other",
+        value: "server",
+        extra: {
+          addonId: TEST_SEARCH_ENGINE_ADDON_ID,
+          addonVersion: TEST_SEARCH_ENGINE_ADDON_VERSION,
+          from: "example.com",
+          to: "example.net",
+        },
+      },
+    ],
+  });
+});
+
+add_task(function test_redirect_three_hops() {
+  return testServerSideRedirect({
+    // test1.example.com -> test2.example.com -> www.example.com -> example.net
+    searchURL: SEARCH_URL_TEST1,
+    expectedEvents: [
+      {
+        object: "other",
+        value: "server",
+        extra: {
+          addonId: TEST_SEARCH_ENGINE_ADDON_ID,
+          addonVersion: TEST_SEARCH_ENGINE_ADDON_VERSION,
+          from: "example.com",
+          to: "example.net",
+        },
+      },
+    ],
+  });
+});
+
+add_task(function test_no_event_when_search_engine_not_used() {
+  return testServerSideRedirect({
+    // www.example.com -> example.net
+    searchURL: SEARCH_URL_WWW,
+    // We do not expect any events because the user is not using the search
+    // engine that was registered.
+    tabURL: "http://mochi.test:8888/search?q=foobar",
+    expectedEvents: [],
+  });
+});
+
+add_task(function test_redirect_chain_does_not_start_on_first_request() {
+  return testServerSideRedirect({
+    // www.example.com -> example.net
+    searchURL: SEARCH_URL_WWW,
+    // User first navigates to an URL that isn't monitored and will be
+    // redirected to another URL that is monitored.
+    tabURL: `http://mochi.test:8888/browser/browser/extensions/search-detection/tests/browser/redirect.sjs?q={searchTerms}`,
+    expectedEvents: [
+      {
+        object: "other",
+        value: "server",
+        extra: {
+          addonId: TEST_SEARCH_ENGINE_ADDON_ID,
+          addonVersion: TEST_SEARCH_ENGINE_ADDON_VERSION,
+          // We expect this and not `mochi.test` because we do not monitor
+          // `mochi.test`, only `example.com`, which is coming from the search
+          // engine registered in the test setup.
+          from: "example.com",
+          to: "example.net",
+        },
+      },
+    ],
+  });
+});
+
+add_task(async function test_two_extensions_reported() {
+  Services.telemetry.clearEvents();
+
+  const searchEngines = [];
+  for (const [addonId, addonVersion, isDefault] of [
+    ["1-addon@guid", "1.2", false],
+    ["2-addon@guid", "3.4", true],
+  ]) {
+    const searchEngine = ExtensionTestUtils.loadExtension({
+      manifest: {
+        version: addonVersion,
+        browser_specific_settings: {
+          gecko: { id: addonId },
+        },
+        chrome_settings_overrides: {
+          search_provider: {
+            is_default: isDefault,
+            name: `test search engine - ${addonId}`,
+            keyword: "test",
+            search_url: `${SEARCH_URL_WWW}&id=${addonId}`,
+          },
+        },
+      },
+      useAddonManager: "temporary",
+    });
+
+    await searchEngine.startup();
+    await AddonTestUtils.waitForSearchProviderStartup(searchEngine);
+
+    searchEngines.push(searchEngine);
+  }
+
+  // Simulate a search by navigating to it.
+  const url = SEARCH_URL_WWW.replace("{searchTerms}", "some terms");
+  await BrowserTestUtils.withNewTab("about:blank", async browser => {
+    // Wait for the tab to be fully loaded.
+    let loaded = BrowserTestUtils.browserLoaded(browser);
+    BrowserTestUtils.loadURIString(browser, url);
+    await loaded;
+  });
+
+  await Promise.all(searchEngines.map(engine => engine.unload()));
+
+  TelemetryTestUtils.assertEvents(
+    [
+      {
+        object: "other",
+        value: "server",
+        extra: {
+          addonId: "1-addon@guid",
+          addonVersion: "1.2",
+          from: "example.com",
+          to: "example.net",
+        },
+      },
+      {
+        object: "other",
+        value: "server",
+        extra: {
+          addonId: "2-addon@guid",
+          addonVersion: "3.4",
+          from: "example.com",
+          to: "example.net",
+        },
+      },
+    ],
+    TELEMETRY_EVENTS_FILTERS,
+    TELEMETRY_TEST_UTILS_OPTIONS
+  );
+});
diff --git a/browser/extensions/search-detection/tests/browser/redirect.sjs b/browser/extensions/search-detection/tests/browser/redirect.sjs
new file mode 100644
index 0000000000..27cb29b32e
--- /dev/null
+++ b/browser/extensions/search-detection/tests/browser/redirect.sjs
@@ -0,0 +1,32 @@
+const REDIRECT_SJS =
+  "browser/browser/extensions/search-detection/tests/browser/redirect.sjs";
+
+// This handler is used to create redirect chains with multiple sub-domains,
+// and the next hop is defined by the current `host`.
+function handleRequest(request, response) {
+  let newLocation;
+
+  // test1.example.com -> test2.example.com -> www.example.com -> example.net
+  switch (request.host) {
+    case "test1.example.com":
+      newLocation = `https://test2.example.com/${REDIRECT_SJS}`;
+      break;
+    case "test2.example.com":
+      newLocation = `https://www.example.com/${REDIRECT_SJS}`;
+      break;
+    case "www.example.com":
+      newLocation = "https://example.net/";
+      break;
+    // We redirect `mochi.test` to `www` in
+    // `test_redirect_chain_does_not_start_on_first_request()`.
+    case "mochi.test":
+      newLocation = `https://www.example.com/${REDIRECT_SJS}`;
+      break;
+    default:
+      // Redirect to a different website in case of unexpected events.
+      newLocation = "https://mozilla.org/";
+  }
+
+  response.setStatusLine(request.httpVersion, 302, "Found");
+  response.setHeader("Location", newLocation);
+}