1 files changed, 277 insertions, 0 deletions
diff --git a/browser/components/downloads/test/unit/test_DownloadsViewableInternally.js b/browser/components/downloads/test/unit/test_DownloadsViewableInternally.js
new file mode 100644
index 0000000000..07925bc7d5
--- /dev/null
+++ b/browser/components/downloads/test/unit/test_DownloadsViewableInternally.js
@@ -0,0 +1,277 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+const PREF_SVG_DISABLED = "svg.disabled";
+const PREF_WEBP_ENABLED = "image.webp.enabled";
+const PREF_AVIF_ENABLED = "image.avif.enabled";
+const PDF_MIME = "application/pdf";
+const OCTET_MIME = "application/octet-stream";
+const XML_MIME = "text/xml";
+const SVG_MIME = "image/svg+xml";
+const AVIF_MIME = "image/avif";
+const WEBP_MIME = "image/webp";
+
+const { Integration } = ChromeUtils.importESModule(
+  "resource://gre/modules/Integration.sys.mjs"
+);
+const {
+  DownloadsViewableInternally,
+  PREF_ENABLED_TYPES,
+  PREF_BRANCH_WAS_REGISTERED,
+  PREF_BRANCH_PREVIOUS_ACTION,
+  PREF_BRANCH_PREVIOUS_ASK,
+} = ChromeUtils.importESModule(
+  "resource:///modules/DownloadsViewableInternally.sys.mjs"
+);
+
+/* global DownloadIntegration */
+Integration.downloads.defineESModuleGetter(
+  this,
+  "DownloadIntegration",
+  "resource://gre/modules/DownloadIntegration.sys.mjs"
+);
+
+const HandlerService = Cc[
+  "@mozilla.org/uriloader/handler-service;1"
+].getService(Ci.nsIHandlerService);
+const MIMEService = Cc["@mozilla.org/mime;1"].getService(Ci.nsIMIMEService);
+
+function checkPreferInternal(mime, ext, expectedPreferInternal) {
+  const handler = MIMEService.getFromTypeAndExtension(mime, ext);
+  if (expectedPreferInternal) {
+    Assert.equal(
+      handler?.preferredAction,
+      Ci.nsIHandlerInfo.handleInternally,
+      `checking ${mime} preferredAction == handleInternally`
+    );
+  } else {
+    Assert.notEqual(
+      handler?.preferredAction,
+      Ci.nsIHandlerInfo.handleInternally,
+      `checking ${mime} preferredAction != handleInternally`
+    );
+  }
+}
+
+function shouldView(mime, ext) {
+  return DownloadIntegration.shouldViewDownloadInternally(mime, ext);
+}
+
+function checkShouldView(mime, ext, expectedShouldView) {
+  Assert.equal(
+    shouldView(mime, ext),
+    expectedShouldView,
+    `checking ${mime} shouldViewDownloadInternally`
+  );
+}
+
+function checkWasRegistered(ext, expectedWasRegistered) {
+  Assert.equal(
+    Services.prefs.getBoolPref(PREF_BRANCH_WAS_REGISTERED + ext, false),
+    expectedWasRegistered,
+    `checking ${ext} was registered pref`
+  );
+}
+
+function checkAll(mime, ext, expected) {
+  checkPreferInternal(mime, ext, expected && ext != "xml" && ext != "svg");
+  checkShouldView(mime, ext, expected);
+  if (ext != "xml" && ext != "svg") {
+    checkWasRegistered(ext, expected);
+  }
+}
+
+add_task(async function test_viewable_internally() {
+  Services.prefs.setCharPref(PREF_ENABLED_TYPES, "xml , svg,avif,webp");
+  Services.prefs.setBoolPref(PREF_SVG_DISABLED, false);
+  Services.prefs.setBoolPref(PREF_WEBP_ENABLED, true);
+  Services.prefs.setBoolPref(PREF_AVIF_ENABLED, true);
+
+  checkAll(XML_MIME, "xml", false);
+  checkAll(SVG_MIME, "svg", false);
+  checkAll(WEBP_MIME, "webp", false);
+  checkAll(AVIF_MIME, "avif", false);
+
+  DownloadsViewableInternally.register();
+
+  checkAll(XML_MIME, "xml", true);
+  checkAll(SVG_MIME, "svg", true);
+  checkAll(WEBP_MIME, "webp", true);
+  checkAll(AVIF_MIME, "avif", true);
+
+  // Remove webp so it won't be cleared
+  Services.prefs.clearUserPref(PREF_BRANCH_WAS_REGISTERED + "webp");
+
+  // Disable xml, avif and webp, check that avif becomes disabled
+  Services.prefs.setCharPref(PREF_ENABLED_TYPES, "svg");
+
+  // (XML is externally managed, and we just cleared the webp pref)
+  checkAll(XML_MIME, "xml", true);
+  checkPreferInternal(WEBP_MIME, "webp", true);
+
+  // Avif should be disabled
+  checkAll(AVIF_MIME, "avif", false);
+
+  // SVG shouldn't be cleared as it's still enabled
+  checkAll(SVG_MIME, "svg", true);
+
+  Assert.ok(
+    shouldView(PDF_MIME),
+    "application/pdf should be unaffected by pref"
+  );
+  Assert.ok(
+    shouldView(OCTET_MIME, "pdf"),
+    ".pdf should be accepted by extension"
+  );
+  Assert.ok(
+    shouldView(OCTET_MIME, "PDF"),
+    ".pdf should be detected case-insensitively"
+  );
+  Assert.ok(!shouldView(OCTET_MIME, "exe"), ".exe shouldn't be accepted");
+
+  Assert.ok(!shouldView(WEBP_MIME), "imave/webp should be disabled by pref");
+  Assert.ok(!shouldView(AVIF_MIME), "image/avif should be disabled by pref");
+
+  // Enable, check that everything is enabled again
+  Services.prefs.setCharPref(PREF_ENABLED_TYPES, "xml,svg,webp,avif");
+
+  checkAll(XML_MIME, "xml", true);
+  checkAll(SVG_MIME, "svg", true);
+  checkPreferInternal(WEBP_MIME, "webp", true);
+  checkPreferInternal(AVIF_MIME, "avif", true);
+
+  Assert.ok(
+    shouldView(PDF_MIME),
+    "application/pdf should be unaffected by pref"
+  );
+  Assert.ok(shouldView(XML_MIME), "text/xml should be enabled by pref");
+  Assert.ok(
+    shouldView("application/xml"),
+    "alternate MIME type application/xml should be accepted"
+  );
+  Assert.ok(
+    shouldView(OCTET_MIME, "xml"),
+    ".xml should be accepted by extension"
+  );
+
+  // Disable viewable internally, pre-set handlers.
+  Services.prefs.setCharPref(PREF_ENABLED_TYPES, "");
+
+  for (const [mime, ext, action, ask] of [
+    [XML_MIME, "xml", Ci.nsIHandlerInfo.useSystemDefault, true],
+    [SVG_MIME, "svg", Ci.nsIHandlerInfo.saveToDisk, true],
+    [WEBP_MIME, "webp", Ci.nsIHandlerInfo.saveToDisk, false],
+  ]) {
+    let handler = MIMEService.getFromTypeAndExtension(mime, ext);
+    handler.preferredAction = action;
+    handler.alwaysAskBeforeHandling = ask;
+
+    HandlerService.store(handler);
+    checkPreferInternal(mime, ext, false);
+
+    // Expect to read back the same values
+    handler = MIMEService.getFromTypeAndExtension(mime, ext);
+    Assert.equal(handler.preferredAction, action);
+    Assert.equal(handler.alwaysAskBeforeHandling, ask);
+  }
+
+  // Enable viewable internally, SVG and XML should not be replaced, WebP should be saved.
+  Services.prefs.setCharPref(PREF_ENABLED_TYPES, "svg,webp,xml");
+
+  Assert.equal(
+    Services.prefs.prefHasUserValue(PREF_BRANCH_PREVIOUS_ACTION + "svg"),
+    false,
+    "svg action should not be stored"
+  );
+  Assert.equal(
+    Services.prefs.prefHasUserValue(PREF_BRANCH_PREVIOUS_ASK + "svg"),
+    false,
+    "svg ask should not be stored"
+  );
+  Assert.equal(
+    Services.prefs.getIntPref(PREF_BRANCH_PREVIOUS_ACTION + "webp"),
+    Ci.nsIHandlerInfo.saveToDisk,
+    "webp action should be saved"
+  );
+  Assert.equal(
+    Services.prefs.getBoolPref(PREF_BRANCH_PREVIOUS_ASK + "webp"),
+    false,
+    "webp ask should be saved"
+  );
+
+  {
+    let handler = MIMEService.getFromTypeAndExtension(SVG_MIME, "svg");
+    Assert.equal(
+      handler.preferredAction,
+      Ci.nsIHandlerInfo.saveToDisk,
+      "svg action should be preserved"
+    );
+    Assert.equal(
+      !!handler.alwaysAskBeforeHandling,
+      true,
+      "svg ask should be preserved"
+    );
+    // Clean up
+    HandlerService.remove(handler);
+    handler = MIMEService.getFromTypeAndExtension(XML_MIME, "xml");
+    Assert.equal(
+      handler.preferredAction,
+      Ci.nsIHandlerInfo.useSystemDefault,
+      "xml action should be preserved"
+    );
+    Assert.equal(
+      !!handler.alwaysAskBeforeHandling,
+      true,
+      "xml ask should be preserved"
+    );
+    // Clean up
+    HandlerService.remove(handler);
+  }
+  // It should still be possible to view XML internally
+  checkShouldView(XML_MIME, "xml", true);
+
+  checkAll(SVG_MIME, "svg", true);
+  checkAll(WEBP_MIME, "webp", true);
+
+  // Disable SVG to test SVG enabled check (depends on the pref)
+  Services.prefs.setBoolPref(PREF_SVG_DISABLED, true);
+  checkAll(SVG_MIME, "svg", false);
+  Services.prefs.setBoolPref(PREF_SVG_DISABLED, false);
+  {
+    let handler = MIMEService.getFromTypeAndExtension(SVG_MIME, "svg");
+    handler.preferredAction = Ci.nsIHandlerInfo.saveToDisk;
+    handler.alwaysAskBeforeHandling = false;
+    HandlerService.store(handler);
+  }
+
+  checkAll(SVG_MIME, "svg", true);
+
+  // Test WebP enabled check (depends on the pref)
+  Services.prefs.setBoolPref(PREF_WEBP_ENABLED, false);
+  // Should have restored the settings from above
+  {
+    let handler = MIMEService.getFromTypeAndExtension(WEBP_MIME, "webp");
+    Assert.equal(handler.preferredAction, Ci.nsIHandlerInfo.saveToDisk);
+    Assert.equal(!!handler.alwaysAskBeforeHandling, false);
+    // Clean up
+    HandlerService.remove(handler);
+  }
+  checkAll(WEBP_MIME, "webp", false);
+
+  Services.prefs.setBoolPref(PREF_WEBP_ENABLED, true);
+  checkAll(WEBP_MIME, "webp", true);
+
+  Assert.ok(!shouldView(null, "pdf"), "missing MIME shouldn't be accepted");
+  Assert.ok(!shouldView(null, "xml"), "missing MIME shouldn't be accepted");
+  Assert.ok(!shouldView(OCTET_MIME), "unsupported MIME shouldn't be accepted");
+  Assert.ok(!shouldView(OCTET_MIME, "exe"), ".exe shouldn't be accepted");
+});
+
+registerCleanupFunction(() => {
+  // Clear all types to remove any saved values
+  Services.prefs.setCharPref(PREF_ENABLED_TYPES, "");
+  // Reset to the defaults
+  Services.prefs.clearUserPref(PREF_ENABLED_TYPES);
+  Services.prefs.clearUserPref(PREF_SVG_DISABLED);
+  Services.prefs.clearUserPref(PREF_WEBP_ENABLED);
+});