Source code
Revision control
Copy as Markdown
Other Tools
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
/*
* TODO: This is based on what PdfJs was already doing, it would be
* best to use this over there as well to reduce duplication and
* inconsistency.
*/
import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
const lazy = {};
XPCOMUtils.defineLazyServiceGetter(
lazy,
"HandlerService",
"@mozilla.org/uriloader/handler-service;1",
"nsIHandlerService"
);
XPCOMUtils.defineLazyServiceGetter(
lazy,
"MIMEService",
"@mozilla.org/mime;1",
"nsIMIMEService"
);
ChromeUtils.defineESModuleGetters(lazy, {
Integration: "resource://gre/modules/Integration.sys.mjs",
});
const PREF_BRANCH = "browser.download.viewableInternally.";
export const PREF_ENABLED_TYPES = PREF_BRANCH + "enabledTypes";
export const PREF_BRANCH_WAS_REGISTERED = PREF_BRANCH + "typeWasRegistered.";
export const PREF_BRANCH_PREVIOUS_ACTION =
PREF_BRANCH + "previousHandler.preferredAction.";
export const PREF_BRANCH_PREVIOUS_ASK =
PREF_BRANCH + "previousHandler.alwaysAskBeforeHandling.";
export let DownloadsViewableInternally = {
/**
* Initially add/remove handlers, watch pref, register with Integration.downloads.
*/
register() {
// Watch the pref
XPCOMUtils.defineLazyPreferenceGetter(
this,
"_enabledTypes",
PREF_ENABLED_TYPES,
"",
() => this._updateAllHandlers(),
pref => {
let itemStr = pref.trim();
return itemStr ? itemStr.split(",").map(s => s.trim()) : [];
}
);
for (let handlerType of this._downloadTypesViewableInternally) {
if (handlerType.initAvailable) {
handlerType.initAvailable();
}
}
// Initially update handlers
this._updateAllHandlers();
// Register the check for use in DownloadIntegration
lazy.Integration.downloads.register(() => ({
shouldViewDownloadInternally:
this._shouldViewDownloadInternally.bind(this),
}));
},
/**
* MIME types to handle with an internal viewer, for downloaded files.
*
* |extension| is an extenson that will be viewable, as an alternative for
* the MIME type itself. It is also used more generally to identify this
* type: It is part of a pref name to indicate the handler was set up once,
* and it is the string present in |PREF_ENABLED_TYPES| to enable the type.
*
* |mimeTypes| are the types that will be viewable. A handler is set up for
* the first element in the array.
*
* If |managedElsewhere| is falsy, |_updateAllHandlers()| will set
* up or remove handlers for the type, and |_shouldViewDownloadInternally()|
* will check for it in |PREF_ENABLED_TYPES|.
*
* |available| is used to check whether this type should have
* handleInternally handlers set up, and if false then
* |_shouldViewDownloadInternally()| will also return false for this
* type. If |available| would change, |DownloadsViewableInternally._updateHandler()|
* should be called for the type.
*
* |initAvailable()| is an opportunity to initially set |available|, set up
* observers to change it when prefs change, etc.
*
*/
_downloadTypesViewableInternally: [
{
extension: "xml",
mimeTypes: ["text/xml", "application/xml"],
available: true,
managedElsewhere: true,
},
{
extension: "svg",
mimeTypes: ["image/svg+xml"],
initAvailable() {
XPCOMUtils.defineLazyPreferenceGetter(
this,
"available",
"svg.disabled",
true,
() => DownloadsViewableInternally._updateHandler(this),
// transform disabled to enabled/available
disabledPref => !disabledPref
);
},
// available getter is set by initAvailable()
managedElsewhere: true,
},
{
extension: "webp",
mimeTypes: ["image/webp"],
available: true,
managedElsewhere: false,
},
{
extension: "avif",
mimeTypes: ["image/avif"],
initAvailable() {
XPCOMUtils.defineLazyPreferenceGetter(
this,
"available",
"image.avif.enabled",
false,
() => DownloadsViewableInternally._updateHandler(this)
);
},
// available getter is set by initAvailable()
},
{
extension: "jxl",
mimeTypes: ["image/jxl"],
initAvailable() {
XPCOMUtils.defineLazyPreferenceGetter(
this,
"available",
"image.jxl.enabled",
false,
() => DownloadsViewableInternally._updateHandler(this)
);
},
// available getter is set by initAvailable()
},
{
extension: "pdf",
mimeTypes: ["application/pdf"],
// PDF uses pdfjs.disabled rather than PREF_ENABLED_TYPES.
// pdfjs.disabled isn't checked here because PdfJs's own _becomeHandler
// and _unbecomeHandler manage the handler if the pref is set, and there
// is an explicit check in nsUnknownContentTypeDialog.shouldShowInternalHandlerOption
available: true,
managedElsewhere: true,
},
],
/*
* Implementation for DownloadIntegration.shouldViewDownloadInternally
*/
_shouldViewDownloadInternally(aMimeType, aExtension) {
if (!aMimeType) {
return false;
}
return this._downloadTypesViewableInternally.some(handlerType => {
if (
!handlerType.managedElsewhere &&
!this._enabledTypes.includes(handlerType.extension)
) {
return false;
}
return (
(handlerType.mimeTypes.includes(aMimeType) ||
handlerType.extension == aExtension?.toLowerCase()) &&
handlerType.available
);
});
},
_makeFakeHandler(aMimeType, aExtension) {
// Based on PdfJs gPdfFakeHandlerInfo.
return {
QueryInterface: ChromeUtils.generateQI(["nsIMIMEInfo"]),
getFileExtensions() {
return [aExtension];
},
possibleApplicationHandlers: Cc["@mozilla.org/array;1"].createInstance(
Ci.nsIMutableArray
),
extensionExists(ext) {
return ext == aExtension;
},
alwaysAskBeforeHandling: false,
preferredAction: Ci.nsIHandlerInfo.handleInternally,
type: aMimeType,
};
},
_saveSettings(handlerInfo, handlerType) {
Services.prefs.setIntPref(
PREF_BRANCH_PREVIOUS_ACTION + handlerType.extension,
handlerInfo.preferredAction
);
Services.prefs.setBoolPref(
PREF_BRANCH_PREVIOUS_ASK + handlerType.extension,
handlerInfo.alwaysAskBeforeHandling
);
},
_restoreSettings(handlerInfo, handlerType) {
const prevActionPref = PREF_BRANCH_PREVIOUS_ACTION + handlerType.extension;
if (Services.prefs.prefHasUserValue(prevActionPref)) {
handlerInfo.alwaysAskBeforeHandling = Services.prefs.getBoolPref(
PREF_BRANCH_PREVIOUS_ASK + handlerType.extension
);
handlerInfo.preferredAction = Services.prefs.getIntPref(prevActionPref);
lazy.HandlerService.store(handlerInfo);
} else {
// Nothing to restore, just remove the handler.
lazy.HandlerService.remove(handlerInfo);
}
},
_clearSavedSettings(extension) {
Services.prefs.clearUserPref(PREF_BRANCH_PREVIOUS_ACTION + extension);
Services.prefs.clearUserPref(PREF_BRANCH_PREVIOUS_ASK + extension);
},
_updateAllHandlers() {
// Set up or remove handlers for each type, if not done already
for (const handlerType of this._downloadTypesViewableInternally) {
if (!handlerType.managedElsewhere) {
this._updateHandler(handlerType);
}
}
},
_updateHandler(handlerType) {
const wasRegistered = Services.prefs.getBoolPref(
PREF_BRANCH_WAS_REGISTERED + handlerType.extension,
false
);
const toBeRegistered =
this._enabledTypes.includes(handlerType.extension) &&
handlerType.available;
if (toBeRegistered && !wasRegistered) {
this._becomeHandler(handlerType);
} else if (!toBeRegistered && wasRegistered) {
this._unbecomeHandler(handlerType);
}
},
_becomeHandler(handlerType) {
// Set up an empty handler with only a preferred action, to avoid
// having to ask the OS about handlers on startup.
let fakeHandlerInfo = this._makeFakeHandler(
handlerType.mimeTypes[0],
handlerType.extension
);
if (!lazy.HandlerService.exists(fakeHandlerInfo)) {
lazy.HandlerService.store(fakeHandlerInfo);
} else {
const handlerInfo = lazy.MIMEService.getFromTypeAndExtension(
handlerType.mimeTypes[0],
handlerType.extension
);
if (handlerInfo.preferredAction != Ci.nsIHandlerInfo.handleInternally) {
// Save the previous settings of preferredAction and
// alwaysAskBeforeHandling in case we need to revert them.
// Even if we don't force preferredAction here, the user could
// set handleInternally manually.
this._saveSettings(handlerInfo, handlerType);
} else {
// handleInternally shouldn't already have been set, the best we
// can do to restore is to remove the handler, so make sure
// the settings are clear.
this._clearSavedSettings(handlerType.extension);
}
// Replace the preferred action if it didn't indicate an external viewer.
// Note: This is a point of departure from PdfJs, which always replaces
// the preferred action.
if (
handlerInfo.preferredAction != Ci.nsIHandlerInfo.useHelperApp &&
handlerInfo.preferredAction != Ci.nsIHandlerInfo.useSystemDefault
) {
handlerInfo.preferredAction = Ci.nsIHandlerInfo.handleInternally;
handlerInfo.alwaysAskBeforeHandling = false;
lazy.HandlerService.store(handlerInfo);
}
}
// Note that we set up for this type so a) we don't keep replacing the
// handler and b) so it can be cleared later.
Services.prefs.setBoolPref(
PREF_BRANCH_WAS_REGISTERED + handlerType.extension,
true
);
},
_unbecomeHandler(handlerType) {
let handlerInfo;
try {
handlerInfo = lazy.MIMEService.getFromTypeAndExtension(
handlerType.mimeTypes[0],
handlerType.extension
);
} catch (ex) {
// Allow the handler lookup to fail.
}
// Restore preferred action if it is still handleInternally
// (possibly just removing the handler if nothing was saved for it).
if (handlerInfo?.preferredAction == Ci.nsIHandlerInfo.handleInternally) {
this._restoreSettings(handlerInfo, handlerType);
}
// In any case we do not control this handler now.
this._clearSavedSettings(handlerType.extension);
Services.prefs.clearUserPref(
PREF_BRANCH_WAS_REGISTERED + handlerType.extension
);
},
};