summaryrefslogtreecommitdiffstats
path: root/toolkit/components/pdfjs/content/PdfStreamConverter.sys.mjs
diff options
context:
space:
mode:
Diffstat (limited to 'toolkit/components/pdfjs/content/PdfStreamConverter.sys.mjs')
-rw-r--r--toolkit/components/pdfjs/content/PdfStreamConverter.sys.mjs1249
1 files changed, 1249 insertions, 0 deletions
diff --git a/toolkit/components/pdfjs/content/PdfStreamConverter.sys.mjs b/toolkit/components/pdfjs/content/PdfStreamConverter.sys.mjs
new file mode 100644
index 0000000000..7f9eea1b45
--- /dev/null
+++ b/toolkit/components/pdfjs/content/PdfStreamConverter.sys.mjs
@@ -0,0 +1,1249 @@
+/* Copyright 2012 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const PDFJS_EVENT_ID = "pdf.js.message";
+const PREF_PREFIX = "pdfjs";
+const PDF_VIEWER_ORIGIN = "resource://pdf.js";
+const PDF_VIEWER_WEB_PAGE = "resource://pdf.js/web/viewer.html";
+const MAX_NUMBER_OF_PREFS = 50;
+const MAX_STRING_PREF_LENGTH = 128;
+const PDF_CONTENT_TYPE = "application/pdf";
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+import { AppConstants } from "resource://gre/modules/AppConstants.sys.mjs";
+
+const lazy = {};
+ChromeUtils.defineESModuleGetters(lazy, {
+ AsyncPrefs: "resource://gre/modules/AsyncPrefs.sys.mjs",
+ NetworkManager: "resource://pdf.js/PdfJsNetwork.sys.mjs",
+ PdfJs: "resource://pdf.js/PdfJs.sys.mjs",
+ PdfJsTelemetry: "resource://pdf.js/PdfJsTelemetry.sys.mjs",
+ PdfSandbox: "resource://pdf.js/PdfSandbox.sys.mjs",
+ PrivateBrowsingUtils: "resource://gre/modules/PrivateBrowsingUtils.sys.mjs",
+});
+ChromeUtils.defineModuleGetter(
+ lazy,
+ "NetUtil",
+ "resource://gre/modules/NetUtil.jsm"
+);
+
+var Svc = {};
+XPCOMUtils.defineLazyServiceGetter(
+ Svc,
+ "mime",
+ "@mozilla.org/mime;1",
+ "nsIMIMEService"
+);
+XPCOMUtils.defineLazyServiceGetter(
+ Svc,
+ "handlers",
+ "@mozilla.org/uriloader/handler-service;1",
+ "nsIHandlerService"
+);
+
+XPCOMUtils.defineLazyGetter(lazy, "gOurBinary", () => {
+ let file = Services.dirsvc.get("XREExeF", Ci.nsIFile);
+ // Make sure to get the .app on macOS
+ if (AppConstants.platform == "macosx") {
+ while (file) {
+ if (/\.app\/?$/i.test(file.leafName)) {
+ break;
+ }
+ file = file.parent;
+ }
+ }
+ return file;
+});
+
+function getBoolPref(pref, def) {
+ try {
+ return Services.prefs.getBoolPref(pref);
+ } catch (ex) {
+ return def;
+ }
+}
+
+function getIntPref(pref, def) {
+ try {
+ return Services.prefs.getIntPref(pref);
+ } catch (ex) {
+ return def;
+ }
+}
+
+function getStringPref(pref, def) {
+ try {
+ return Services.prefs.getStringPref(pref);
+ } catch (ex) {
+ return def;
+ }
+}
+
+function log(aMsg) {
+ if (!getBoolPref(PREF_PREFIX + ".pdfBugEnabled", false)) {
+ return;
+ }
+ var msg = "PdfStreamConverter.js: " + (aMsg.join ? aMsg.join("") : aMsg);
+ Services.console.logStringMessage(msg);
+ dump(msg + "\n");
+}
+
+function getDOMWindow(aChannel, aPrincipal) {
+ var requestor = aChannel.notificationCallbacks
+ ? aChannel.notificationCallbacks
+ : aChannel.loadGroup.notificationCallbacks;
+ var win = requestor.getInterface(Ci.nsIDOMWindow);
+ // Ensure the window wasn't navigated to something that is not PDF.js.
+ if (!win.document.nodePrincipal.equals(aPrincipal)) {
+ return null;
+ }
+ return win;
+}
+
+function getActor(window) {
+ try {
+ const actorName =
+ AppConstants.platform === "android" ? "GeckoViewPdfjs" : "Pdfjs";
+ return window.windowGlobalChild.getActor(actorName);
+ } catch (ex) {
+ return null;
+ }
+}
+
+function getLocalizedStrings(path) {
+ var stringBundle = Services.strings.createBundle(
+ "chrome://pdf.js/locale/" + path
+ );
+
+ var map = {};
+ for (let string of stringBundle.getSimpleEnumeration()) {
+ var key = string.key,
+ property = "textContent";
+ var i = key.lastIndexOf(".");
+ if (i >= 0) {
+ property = key.substring(i + 1);
+ key = key.substring(0, i);
+ }
+ if (!(key in map)) {
+ map[key] = {};
+ }
+ map[key][property] = string.value;
+ }
+ return map;
+}
+
+function isValidMatchesCount(data) {
+ if (typeof data !== "object" || data === null) {
+ return false;
+ }
+ const { current, total } = data;
+ if (
+ typeof total !== "number" ||
+ total < 0 ||
+ typeof current !== "number" ||
+ current < 0 ||
+ current > total
+ ) {
+ return false;
+ }
+ return true;
+}
+
+// PDF data storage
+function PdfDataListener(length) {
+ this.length = length; // less than 0, if length is unknown
+ this.buffers = [];
+ this.loaded = 0;
+}
+
+PdfDataListener.prototype = {
+ append: function PdfDataListener_append(chunk) {
+ // In most of the cases we will pass data as we receive it, but at the
+ // beginning of the loading we may accumulate some data.
+ this.buffers.push(chunk);
+ this.loaded += chunk.length;
+ if (this.length >= 0 && this.length < this.loaded) {
+ this.length = -1; // reset the length, server is giving incorrect one
+ }
+ this.onprogress(this.loaded, this.length >= 0 ? this.length : void 0);
+ },
+ readData: function PdfDataListener_readData() {
+ if (this.buffers.length === 0) {
+ return null;
+ }
+ if (this.buffers.length === 1) {
+ return this.buffers.pop();
+ }
+ // There are multiple buffers that need to be combined into a single
+ // buffer.
+ let combinedLength = 0;
+ for (let buffer of this.buffers) {
+ combinedLength += buffer.length;
+ }
+ let combinedArray = new Uint8Array(combinedLength);
+ let writeOffset = 0;
+ while (this.buffers.length) {
+ let buffer = this.buffers.shift();
+ combinedArray.set(buffer, writeOffset);
+ writeOffset += buffer.length;
+ }
+ return combinedArray;
+ },
+ get isDone() {
+ return !!this.isDataReady;
+ },
+ finish: function PdfDataListener_finish() {
+ this.isDataReady = true;
+ if (this.oncompleteCallback) {
+ this.oncompleteCallback(this.readData());
+ }
+ },
+ error: function PdfDataListener_error(errorCode) {
+ this.errorCode = errorCode;
+ if (this.oncompleteCallback) {
+ this.oncompleteCallback(null, errorCode);
+ }
+ },
+ onprogress() {},
+ get oncomplete() {
+ return this.oncompleteCallback;
+ },
+ set oncomplete(value) {
+ this.oncompleteCallback = value;
+ if (this.isDataReady) {
+ value(this.readData());
+ }
+ if (this.errorCode) {
+ value(null, this.errorCode);
+ }
+ },
+};
+
+/**
+ * All the privileged actions.
+ */
+class ChromeActions {
+ constructor(domWindow, contentDispositionFilename) {
+ this.domWindow = domWindow;
+ this.contentDispositionFilename = contentDispositionFilename;
+ this.sandbox = null;
+ this.unloadListener = null;
+ }
+
+ createSandbox(data, sendResponse) {
+ function sendResp(res) {
+ if (sendResponse) {
+ sendResponse(res);
+ }
+ return res;
+ }
+
+ if (!getBoolPref(PREF_PREFIX + ".enableScripting", false)) {
+ return sendResp(false);
+ }
+
+ if (this.sandbox !== null) {
+ return sendResp(true);
+ }
+
+ try {
+ this.sandbox = new lazy.PdfSandbox(this.domWindow, data);
+ } catch (err) {
+ // If there's an error here, it means that something is really wrong
+ // on pdf.js side during sandbox initialization phase.
+ console.error(err);
+ return sendResp(false);
+ }
+
+ this.unloadListener = () => {
+ this.destroySandbox();
+ };
+ this.domWindow.addEventListener("unload", this.unloadListener);
+
+ return sendResp(true);
+ }
+
+ dispatchEventInSandbox(event) {
+ if (this.sandbox) {
+ this.sandbox.dispatchEvent(event);
+ }
+ }
+
+ dispatchAsyncEventInSandbox(event, sendResponse) {
+ this.dispatchEventInSandbox(event);
+ sendResponse();
+ }
+
+ destroySandbox() {
+ if (this.sandbox) {
+ this.domWindow.removeEventListener("unload", this.unloadListener);
+ this.sandbox.destroy();
+ this.sandbox = null;
+ }
+ }
+
+ isInPrivateBrowsing() {
+ return lazy.PrivateBrowsingUtils.isContentWindowPrivate(this.domWindow);
+ }
+
+ getWindowOriginAttributes() {
+ try {
+ return this.domWindow.document.nodePrincipal.originAttributes;
+ } catch (err) {
+ return {};
+ }
+ }
+
+ download(data, sendResponse) {
+ const { originalUrl, options } = data;
+ const blobUrl = data.blobUrl || originalUrl;
+ let { filename } = data;
+ if (
+ typeof filename !== "string" ||
+ (!/\.pdf$/i.test(filename) && !data.isAttachment)
+ ) {
+ filename = "document.pdf";
+ }
+
+ const actor = getActor(this.domWindow);
+ actor.sendAsyncMessage("PDFJS:Parent:saveURL", {
+ blobUrl,
+ originalUrl,
+ filename,
+ options: options || {},
+ });
+ }
+
+ getLocale() {
+ return Services.locale.requestedLocale || "en-US";
+ }
+
+ getStrings() {
+ try {
+ // Lazy initialization of localizedStrings
+ this.localizedStrings ||= getLocalizedStrings("viewer.properties");
+
+ return this.localizedStrings;
+ } catch (e) {
+ log("Unable to retrieve localized strings: " + e);
+ return null;
+ }
+ }
+
+ supportsIntegratedFind() {
+ // Integrated find is only supported when we're not in a frame
+ return this.domWindow.windowGlobalChild.browsingContext.parent === null;
+ }
+
+ supportsDocumentFonts() {
+ var prefBrowser = getIntPref("browser.display.use_document_fonts", 1);
+ var prefGfx = getBoolPref("gfx.downloadable_fonts.enabled", true);
+ return !!prefBrowser && prefGfx;
+ }
+
+ supportsPinchToZoom() {
+ return getBoolPref("apz.allow_zooming", true);
+ }
+
+ supportedMouseWheelZoomModifierKeys() {
+ return {
+ ctrlKey: getIntPref("mousewheel.with_control.action", 3) === 3,
+ metaKey: getIntPref("mousewheel.with_meta.action", 1) === 3,
+ };
+ }
+
+ getCanvasMaxArea() {
+ return getIntPref("gfx.max-alloc-size", 500000000);
+ }
+
+ isInAutomation() {
+ return Cu.isInAutomation;
+ }
+
+ isMobile() {
+ return AppConstants.platform === "android";
+ }
+
+ getNimbusExperimentData(_data, sendResponse) {
+ if (!this.isMobile()) {
+ sendResponse(null);
+ return;
+ }
+ const actor = getActor(this.domWindow);
+ actor.sendAsyncMessage("PDFJS:Parent:getNimbus");
+ Services.obs.addObserver(
+ {
+ observe(aSubject, aTopic, aData) {
+ if (aTopic === "pdfjs-getNimbus") {
+ Services.obs.removeObserver(this, aTopic);
+ sendResponse(aSubject && JSON.stringify(aSubject.wrappedJSObject));
+ }
+ },
+ },
+ "pdfjs-getNimbus"
+ );
+ }
+
+ reportTelemetry(data) {
+ const probeInfo = JSON.parse(data);
+ const { type } = probeInfo;
+ switch (type) {
+ case "pageInfo":
+ lazy.PdfJsTelemetry.onTimeToView(probeInfo.timestamp);
+ break;
+ case "editing":
+ lazy.PdfJsTelemetry.onEditing(probeInfo.data.type);
+ break;
+ case "buttons":
+ case "gv-buttons":
+ const id = probeInfo.data.id.replace(
+ /([A-Z])/g,
+ c => `_${c.toLowerCase()}`
+ );
+ if (type === "buttons") {
+ lazy.PdfJsTelemetry.onButtons(id);
+ } else {
+ lazy.PdfJsTelemetry.onGeckoview(id);
+ }
+ break;
+ }
+ }
+
+ /**
+ * @param {Object} args - Object with `featureId` and `url` properties.
+ * @param {function} sendResponse - Callback function.
+ */
+ fallback(args, sendResponse) {
+ sendResponse(false);
+ }
+
+ updateFindControlState(data) {
+ if (!this.supportsIntegratedFind()) {
+ return;
+ }
+ // Verify what we're sending to the findbar.
+ var result = data.result;
+ var findPrevious = data.findPrevious;
+ var findPreviousType = typeof findPrevious;
+ if (
+ typeof result !== "number" ||
+ result < 0 ||
+ result > 3 ||
+ (findPreviousType !== "undefined" && findPreviousType !== "boolean")
+ ) {
+ return;
+ }
+ // Allow the `matchesCount` property to be optional, and ensure that
+ // it's valid before including it in the data sent to the findbar.
+ let matchesCount = null;
+ if (isValidMatchesCount(data.matchesCount)) {
+ matchesCount = data.matchesCount;
+ }
+ // Same for the `rawQuery` property.
+ let rawQuery = null;
+ if (typeof data.rawQuery === "string") {
+ rawQuery = data.rawQuery;
+ }
+
+ let actor = getActor(this.domWindow);
+ actor?.sendAsyncMessage("PDFJS:Parent:updateControlState", {
+ result,
+ findPrevious,
+ matchesCount,
+ rawQuery,
+ });
+ }
+
+ updateFindMatchesCount(data) {
+ if (!this.supportsIntegratedFind()) {
+ return;
+ }
+ // Verify what we're sending to the findbar.
+ if (!isValidMatchesCount(data)) {
+ return;
+ }
+
+ let actor = getActor(this.domWindow);
+ actor?.sendAsyncMessage("PDFJS:Parent:updateMatchesCount", data);
+ }
+
+ setPreferences(prefs, sendResponse) {
+ var defaultBranch = Services.prefs.getDefaultBranch(PREF_PREFIX + ".");
+ var numberOfPrefs = 0;
+ var prefValue, prefName;
+ for (var key in prefs) {
+ if (++numberOfPrefs > MAX_NUMBER_OF_PREFS) {
+ log(
+ "setPreferences - Exceeded the maximum number of preferences " +
+ "that is allowed to be set at once."
+ );
+ break;
+ } else if (!defaultBranch.getPrefType(key)) {
+ continue;
+ }
+ prefValue = prefs[key];
+ prefName = PREF_PREFIX + "." + key;
+ switch (typeof prefValue) {
+ case "boolean":
+ lazy.AsyncPrefs.set(prefName, prefValue);
+ break;
+ case "number":
+ lazy.AsyncPrefs.set(prefName, prefValue);
+ break;
+ case "string":
+ if (prefValue.length > MAX_STRING_PREF_LENGTH) {
+ log(
+ "setPreferences - Exceeded the maximum allowed length " +
+ "for a string preference."
+ );
+ } else {
+ lazy.AsyncPrefs.set(prefName, prefValue);
+ }
+ break;
+ }
+ }
+ if (sendResponse) {
+ sendResponse(true);
+ }
+ }
+
+ getPreferences(prefs, sendResponse) {
+ var defaultBranch = Services.prefs.getDefaultBranch(PREF_PREFIX + ".");
+ var currentPrefs = {},
+ numberOfPrefs = 0;
+ var prefValue, prefName;
+ for (var key in prefs) {
+ if (++numberOfPrefs > MAX_NUMBER_OF_PREFS) {
+ log(
+ "getPreferences - Exceeded the maximum number of preferences " +
+ "that is allowed to be fetched at once."
+ );
+ break;
+ } else if (!defaultBranch.getPrefType(key)) {
+ continue;
+ }
+ prefValue = prefs[key];
+ prefName = PREF_PREFIX + "." + key;
+ switch (typeof prefValue) {
+ case "boolean":
+ currentPrefs[key] = getBoolPref(prefName, prefValue);
+ break;
+ case "number":
+ currentPrefs[key] = getIntPref(prefName, prefValue);
+ break;
+ case "string":
+ currentPrefs[key] = getStringPref(prefName, prefValue);
+ break;
+ }
+ }
+ let result = JSON.stringify(currentPrefs);
+ if (sendResponse) {
+ sendResponse(result);
+ }
+ return result;
+ }
+
+ /**
+ * Set the different editor states in order to be able to update the context
+ * menu.
+ * @param {Object} details
+ */
+ updateEditorStates({ details }) {
+ const doc = this.domWindow.document;
+ if (!doc.editorStates) {
+ doc.editorStates = {
+ isEditing: false,
+ isEmpty: true,
+ hasSomethingToUndo: false,
+ hasSomethingToRedo: false,
+ hasSelectedEditor: false,
+ };
+ }
+ const { editorStates } = doc;
+ for (const [key, value] of Object.entries(details)) {
+ if (typeof value === "boolean" && key in editorStates) {
+ editorStates[key] = value;
+ }
+ }
+ }
+}
+
+/**
+ * This is for range requests.
+ */
+class RangedChromeActions extends ChromeActions {
+ constructor(
+ domWindow,
+ contentDispositionFilename,
+ originalRequest,
+ rangeEnabled,
+ streamingEnabled,
+ dataListener
+ ) {
+ super(domWindow, contentDispositionFilename);
+ this.dataListener = dataListener;
+ this.originalRequest = originalRequest;
+ this.rangeEnabled = rangeEnabled;
+ this.streamingEnabled = streamingEnabled;
+
+ this.pdfUrl = originalRequest.URI.spec;
+ this.contentLength = originalRequest.contentLength;
+
+ // Pass all the headers from the original request through
+ var httpHeaderVisitor = {
+ headers: {},
+ visitHeader(aHeader, aValue) {
+ if (aHeader === "Range") {
+ // When loading the PDF from cache, firefox seems to set the Range
+ // request header to fetch only the unfetched portions of the file
+ // (e.g. 'Range: bytes=1024-'). However, we want to set this header
+ // manually to fetch the PDF in chunks.
+ return;
+ }
+ this.headers[aHeader] = aValue;
+ },
+ };
+ if (originalRequest.visitRequestHeaders) {
+ originalRequest.visitRequestHeaders(httpHeaderVisitor);
+ }
+
+ var self = this;
+ var xhr_onreadystatechange = function xhr_onreadystatechange() {
+ if (this.readyState === 1) {
+ // LOADING
+ var netChannel = this.channel;
+ // override this XMLHttpRequest's OriginAttributes with our cached parent window's
+ // OriginAttributes, as we are currently running under the SystemPrincipal
+ this.setOriginAttributes(self.getWindowOriginAttributes());
+ if (
+ "nsIPrivateBrowsingChannel" in Ci &&
+ netChannel instanceof Ci.nsIPrivateBrowsingChannel
+ ) {
+ var docIsPrivate = self.isInPrivateBrowsing();
+ netChannel.setPrivate(docIsPrivate);
+ }
+ }
+ };
+ var getXhr = function getXhr() {
+ var xhr = new XMLHttpRequest();
+ xhr.addEventListener("readystatechange", xhr_onreadystatechange);
+ return xhr;
+ };
+
+ this.networkManager = new lazy.NetworkManager(this.pdfUrl, {
+ httpHeaders: httpHeaderVisitor.headers,
+ getXhr,
+ });
+
+ // If we are in range request mode, this means we manually issued xhr
+ // requests, which we need to abort when we leave the page
+ domWindow.addEventListener("unload", function unload(e) {
+ domWindow.removeEventListener(e.type, unload);
+ self.abortLoading();
+ });
+ }
+
+ initPassiveLoading() {
+ let data, done;
+ if (!this.streamingEnabled) {
+ this.originalRequest.cancel(Cr.NS_BINDING_ABORTED);
+ this.originalRequest = null;
+ data = this.dataListener.readData();
+ done = this.dataListener.isDone;
+ this.dataListener = null;
+ } else {
+ data = this.dataListener.readData();
+ done = this.dataListener.isDone;
+
+ this.dataListener.onprogress = (loaded, total) => {
+ const chunk = this.dataListener.readData();
+
+ this.domWindow.postMessage(
+ {
+ pdfjsLoadAction: "progressiveRead",
+ loaded,
+ total,
+ chunk,
+ },
+ PDF_VIEWER_ORIGIN,
+ chunk ? [chunk.buffer] : undefined
+ );
+ };
+ this.dataListener.oncomplete = () => {
+ if (!done && this.dataListener.isDone) {
+ this.domWindow.postMessage(
+ {
+ pdfjsLoadAction: "progressiveDone",
+ },
+ PDF_VIEWER_ORIGIN
+ );
+ }
+ this.dataListener = null;
+ };
+ }
+
+ this.domWindow.postMessage(
+ {
+ pdfjsLoadAction: "supportsRangedLoading",
+ rangeEnabled: this.rangeEnabled,
+ streamingEnabled: this.streamingEnabled,
+ pdfUrl: this.pdfUrl,
+ length: this.contentLength,
+ data,
+ done,
+ filename: this.contentDispositionFilename,
+ },
+ PDF_VIEWER_ORIGIN,
+ data ? [data.buffer] : undefined
+ );
+
+ return true;
+ }
+
+ requestDataRange(args) {
+ if (!this.rangeEnabled) {
+ return;
+ }
+
+ var begin = args.begin;
+ var end = args.end;
+ var domWindow = this.domWindow;
+ // TODO(mack): Support error handler. We're not currently not handling
+ // errors from chrome code for non-range requests, so this doesn't
+ // seem high-pri
+ this.networkManager.requestRange(begin, end, {
+ onDone: function RangedChromeActions_onDone({ begin, chunk }) {
+ domWindow.postMessage(
+ {
+ pdfjsLoadAction: "range",
+ begin,
+ chunk,
+ },
+ PDF_VIEWER_ORIGIN,
+ chunk ? [chunk.buffer] : undefined
+ );
+ },
+ onProgress: function RangedChromeActions_onProgress(evt) {
+ domWindow.postMessage(
+ {
+ pdfjsLoadAction: "rangeProgress",
+ loaded: evt.loaded,
+ },
+ PDF_VIEWER_ORIGIN
+ );
+ },
+ });
+ }
+
+ abortLoading() {
+ this.networkManager.abortAllRequests();
+ if (this.originalRequest) {
+ this.originalRequest.cancel(Cr.NS_BINDING_ABORTED);
+ this.originalRequest = null;
+ }
+ this.dataListener = null;
+ }
+}
+
+/**
+ * This is for a single network stream.
+ */
+class StandardChromeActions extends ChromeActions {
+ constructor(
+ domWindow,
+ contentDispositionFilename,
+ originalRequest,
+ dataListener
+ ) {
+ super(domWindow, contentDispositionFilename);
+ this.originalRequest = originalRequest;
+ this.dataListener = dataListener;
+ }
+
+ initPassiveLoading() {
+ if (!this.dataListener) {
+ return false;
+ }
+
+ this.dataListener.onprogress = (loaded, total) => {
+ this.domWindow.postMessage(
+ {
+ pdfjsLoadAction: "progress",
+ loaded,
+ total,
+ },
+ PDF_VIEWER_ORIGIN
+ );
+ };
+
+ this.dataListener.oncomplete = (data, errorCode) => {
+ this.domWindow.postMessage(
+ {
+ pdfjsLoadAction: "complete",
+ data,
+ errorCode,
+ filename: this.contentDispositionFilename,
+ },
+ PDF_VIEWER_ORIGIN,
+ data ? [data.buffer] : undefined
+ );
+
+ this.dataListener = null;
+ this.originalRequest = null;
+ };
+
+ return true;
+ }
+
+ abortLoading() {
+ if (this.originalRequest) {
+ this.originalRequest.cancel(Cr.NS_BINDING_ABORTED);
+ this.originalRequest = null;
+ }
+ this.dataListener = null;
+ }
+}
+
+/**
+ * Event listener to trigger chrome privileged code.
+ */
+class RequestListener {
+ constructor(actions) {
+ this.actions = actions;
+ }
+
+ // Receive an event and synchronously or asynchronously responds.
+ receive(event) {
+ var message = event.target;
+ var doc = message.ownerDocument;
+ var action = event.detail.action;
+ var data = event.detail.data;
+ var sync = event.detail.sync;
+ var actions = this.actions;
+ if (!(action in actions)) {
+ log("Unknown action: " + action);
+ return;
+ }
+ var response;
+ if (sync) {
+ response = actions[action].call(this.actions, data);
+ event.detail.response = Cu.cloneInto(response, doc.defaultView);
+ } else {
+ if (!event.detail.responseExpected) {
+ doc.documentElement.removeChild(message);
+ response = null;
+ } else {
+ response = function sendResponse(aResponse) {
+ try {
+ var listener = doc.createEvent("CustomEvent");
+ let detail = Cu.cloneInto({ response: aResponse }, doc.defaultView);
+ listener.initCustomEvent("pdf.js.response", true, false, detail);
+ return message.dispatchEvent(listener);
+ } catch (e) {
+ // doc is no longer accessible because the requestor is already
+ // gone. unloaded content cannot receive the response anyway.
+ return false;
+ }
+ };
+ }
+ actions[action].call(this.actions, data, response);
+ }
+ }
+}
+
+export function PdfStreamConverter() {}
+
+PdfStreamConverter.prototype = {
+ QueryInterface: ChromeUtils.generateQI([
+ "nsIStreamConverter",
+ "nsIStreamListener",
+ "nsIRequestObserver",
+ ]),
+
+ /*
+ * This component works as such:
+ * 1. asyncConvertData stores the listener
+ * 2. onStartRequest creates a new channel, streams the viewer
+ * 3. If range requests are supported:
+ * 3.1. Leave the request open until the viewer is ready to switch to
+ * range requests.
+ *
+ * If range rquests are not supported:
+ * 3.1. Read the stream as it's loaded in onDataAvailable to send
+ * to the viewer
+ *
+ * The convert function just returns the stream, it's just the synchronous
+ * version of asyncConvertData.
+ */
+
+ // nsIStreamConverter::convert
+ convert(aFromStream, aFromType, aToType, aCtxt) {
+ throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED);
+ },
+
+ // nsIStreamConverter::asyncConvertData
+ asyncConvertData(aFromType, aToType, aListener, aCtxt) {
+ if (aCtxt && aCtxt instanceof Ci.nsIChannel) {
+ aCtxt.QueryInterface(Ci.nsIChannel);
+ }
+ // We need to check if we're supposed to convert here, because not all
+ // asyncConvertData consumers will call getConvertedType first:
+ this.getConvertedType(aFromType, aCtxt);
+
+ // Store the listener passed to us
+ this.listener = aListener;
+ },
+
+ _usableHandler(handlerInfo) {
+ let { preferredApplicationHandler } = handlerInfo;
+ if (
+ !preferredApplicationHandler ||
+ !(preferredApplicationHandler instanceof Ci.nsILocalHandlerApp)
+ ) {
+ return false;
+ }
+ preferredApplicationHandler.QueryInterface(Ci.nsILocalHandlerApp);
+ // We have an app, grab the executable
+ let { executable } = preferredApplicationHandler;
+ if (!executable) {
+ return false;
+ }
+ return !executable.equals(lazy.gOurBinary);
+ },
+
+ /*
+ * Check if the user wants to use PDF.js. Returns true if PDF.js should
+ * handle PDFs, and false if not. Will always return true on non-parent
+ * processes.
+ *
+ * If the user has selected to open PDFs with a helper app, and we are that
+ * helper app, or if the user has selected the OS default, and we are that
+ * OS default, reset the preference back to pdf.js .
+ *
+ */
+ _validateAndMaybeUpdatePDFPrefs() {
+ let { processType, PROCESS_TYPE_DEFAULT } = Services.appinfo;
+ // If we're not in the parent, or are the default, then just say yes.
+ if (processType != PROCESS_TYPE_DEFAULT || lazy.PdfJs.cachedIsDefault()) {
+ return { shouldOpen: true };
+ }
+
+ // OK, PDF.js might not be the default. Find out if we've misled the user
+ // into making Firefox an external handler or if we're the OS default and
+ // Firefox is set to use the OS default:
+ let mime = Svc.mime.getFromTypeAndExtension(PDF_CONTENT_TYPE, "pdf");
+ // The above might throw errors. We're deliberately letting those bubble
+ // back up, where they'll tell the stream converter not to use us.
+
+ if (!mime) {
+ // This shouldn't happen, but we can't fix what isn't there. Assume
+ // we're OK to handle with PDF.js
+ return { shouldOpen: true };
+ }
+
+ const { saveToDisk, useHelperApp, useSystemDefault } = Ci.nsIHandlerInfo;
+ let { preferredAction, alwaysAskBeforeHandling } = mime;
+ // return this info so getConvertedType can use it.
+ let rv = { alwaysAskBeforeHandling, shouldOpen: false };
+ // If the user has indicated they want to be asked or want to save to
+ // disk, we shouldn't render inline immediately:
+ if (alwaysAskBeforeHandling || preferredAction == saveToDisk) {
+ return rv;
+ }
+ // If we have usable helper app info, don't use PDF.js
+ if (preferredAction == useHelperApp && this._usableHandler(mime)) {
+ return rv;
+ }
+ // If we want the OS default and that's not Firefox, don't use PDF.js
+ if (preferredAction == useSystemDefault && !mime.isCurrentAppOSDefault()) {
+ return rv;
+ }
+ rv.shouldOpen = true;
+ // Log that we're doing this to help debug issues if people end up being
+ // surprised by this behaviour.
+ console.error("Found unusable PDF preferences. Fixing back to PDF.js");
+
+ mime.preferredAction = Ci.nsIHandlerInfo.handleInternally;
+ mime.alwaysAskBeforeHandling = false;
+ Svc.handlers.store(mime);
+ return true;
+ },
+
+ getConvertedType(aFromType, aChannel) {
+ const HTML = "text/html";
+ let channelURI = aChannel?.URI;
+ // We can be invoked for application/octet-stream; check if we want the
+ // channel first:
+ if (aFromType != "application/pdf") {
+ // Check if the filename has a PDF extension.
+ let isPDF = false;
+ try {
+ isPDF = aChannel.contentDispositionFilename.endsWith(".pdf");
+ } catch (ex) {}
+ if (!isPDF) {
+ isPDF =
+ channelURI?.QueryInterface(Ci.nsIURL).fileExtension.toLowerCase() ==
+ "pdf";
+ }
+
+ let browsingContext = aChannel?.loadInfo.targetBrowsingContext;
+ let toplevelOctetStream =
+ aFromType == "application/octet-stream" &&
+ browsingContext &&
+ !browsingContext.parent;
+ if (
+ !isPDF ||
+ !toplevelOctetStream ||
+ !getBoolPref(PREF_PREFIX + ".handleOctetStream", false)
+ ) {
+ throw new Components.Exception(
+ "Ignore PDF.js for this download.",
+ Cr.NS_ERROR_FAILURE
+ );
+ }
+ // fall through, this appears to be a pdf.
+ }
+
+ let { alwaysAskBeforeHandling, shouldOpen } =
+ this._validateAndMaybeUpdatePDFPrefs();
+
+ if (shouldOpen) {
+ return HTML;
+ }
+ // Hm, so normally, no pdfjs. However... if this is a file: channel there
+ // are some edge-cases.
+ if (channelURI?.schemeIs("file")) {
+ // If we're loaded with system principal, we were likely handed the PDF
+ // by the OS or directly from the URL bar. Assume we should load it:
+ let triggeringPrincipal = aChannel.loadInfo?.triggeringPrincipal;
+ if (triggeringPrincipal?.isSystemPrincipal) {
+ return HTML;
+ }
+
+ // If we're loading from a file: link, load it in PDF.js unless the user
+ // has told us they always want to open/save PDFs.
+ // This is because handing off the choice to open in Firefox itself
+ // through the dialog doesn't work properly and making it work is
+ // non-trivial (see https://bugzilla.mozilla.org/show_bug.cgi?id=1680147#c3 )
+ // - and anyway, opening the file is what we do for *all*
+ // other file types we handle internally (and users can then use other UI
+ // to save or open it with other apps from there).
+ if (triggeringPrincipal?.schemeIs("file") && alwaysAskBeforeHandling) {
+ return HTML;
+ }
+ }
+
+ throw new Components.Exception("Can't use PDF.js", Cr.NS_ERROR_FAILURE);
+ },
+
+ // nsIStreamListener::onDataAvailable
+ onDataAvailable(aRequest, aInputStream, aOffset, aCount) {
+ if (!this.dataListener) {
+ return;
+ }
+
+ var binaryStream = this.binaryStream;
+ binaryStream.setInputStream(aInputStream);
+ let chunk = new ArrayBuffer(aCount);
+ binaryStream.readArrayBuffer(aCount, chunk);
+ this.dataListener.append(new Uint8Array(chunk));
+ },
+
+ // nsIRequestObserver::onStartRequest
+ onStartRequest(aRequest) {
+ // Setup the request so we can use it below.
+ var isHttpRequest = false;
+ try {
+ aRequest.QueryInterface(Ci.nsIHttpChannel);
+ isHttpRequest = true;
+ } catch (e) {}
+
+ var rangeRequest = false;
+ var streamRequest = false;
+ if (isHttpRequest) {
+ var contentEncoding = "identity";
+ try {
+ contentEncoding = aRequest.getResponseHeader("Content-Encoding");
+ } catch (e) {}
+
+ var acceptRanges;
+ try {
+ acceptRanges = aRequest.getResponseHeader("Accept-Ranges");
+ } catch (e) {}
+
+ var hash = aRequest.URI.ref;
+ var isPDFBugEnabled = getBoolPref(PREF_PREFIX + ".pdfBugEnabled", false);
+ rangeRequest =
+ contentEncoding === "identity" &&
+ acceptRanges === "bytes" &&
+ aRequest.contentLength >= 0 &&
+ !getBoolPref(PREF_PREFIX + ".disableRange", false) &&
+ (!isPDFBugEnabled || !hash.toLowerCase().includes("disablerange=true"));
+ streamRequest =
+ contentEncoding === "identity" &&
+ aRequest.contentLength >= 0 &&
+ !getBoolPref(PREF_PREFIX + ".disableStream", false) &&
+ (!isPDFBugEnabled ||
+ !hash.toLowerCase().includes("disablestream=true"));
+ }
+
+ aRequest.QueryInterface(Ci.nsIChannel);
+
+ aRequest.QueryInterface(Ci.nsIWritablePropertyBag);
+
+ var contentDispositionFilename;
+ try {
+ contentDispositionFilename = aRequest.contentDispositionFilename;
+ } catch (e) {}
+
+ if (
+ contentDispositionFilename &&
+ !/\.pdf$/i.test(contentDispositionFilename)
+ ) {
+ contentDispositionFilename += ".pdf";
+ }
+
+ // Change the content type so we don't get stuck in a loop.
+ aRequest.setProperty("contentType", aRequest.contentType);
+ aRequest.contentType = "text/html";
+ if (isHttpRequest) {
+ // We trust PDF viewer, using no CSP
+ aRequest.setResponseHeader("Content-Security-Policy", "", false);
+ aRequest.setResponseHeader(
+ "Content-Security-Policy-Report-Only",
+ "",
+ false
+ );
+ // The viewer does not need to handle HTTP Refresh header.
+ aRequest.setResponseHeader("Refresh", "", false);
+ }
+
+ lazy.PdfJsTelemetry.onViewerIsUsed();
+
+ // The document will be loaded via the stream converter as html,
+ // but since we may have come here via a download or attachment
+ // that was opened directly, force the content disposition to be
+ // inline so that the html document will be loaded normally instead
+ // of going to the helper service.
+ aRequest.contentDisposition = Ci.nsIChannel.DISPOSITION_FORCE_INLINE;
+
+ // Creating storage for PDF data
+ var contentLength = aRequest.contentLength;
+ this.dataListener = new PdfDataListener(contentLength);
+ this.binaryStream = Cc["@mozilla.org/binaryinputstream;1"].createInstance(
+ Ci.nsIBinaryInputStream
+ );
+
+ // Create a new channel that is viewer loaded as a resource.
+ var channel = lazy.NetUtil.newChannel({
+ uri: PDF_VIEWER_WEB_PAGE,
+ loadUsingSystemPrincipal: true,
+ });
+
+ var listener = this.listener;
+ var dataListener = this.dataListener;
+ // Proxy all the request observer calls, when it gets to onStopRequest
+ // we can get the dom window. We also intentionally pass on the original
+ // request(aRequest) below so we don't overwrite the original channel and
+ // trigger an assertion.
+ var proxy = {
+ onStartRequest(request) {
+ listener.onStartRequest(aRequest);
+ },
+ onDataAvailable(request, inputStream, offset, count) {
+ listener.onDataAvailable(aRequest, inputStream, offset, count);
+ },
+ onStopRequest(request, statusCode) {
+ var domWindow = getDOMWindow(channel, resourcePrincipal);
+ if (!Components.isSuccessCode(statusCode) || !domWindow) {
+ // The request may have been aborted and the document may have been
+ // replaced with something that is not PDF.js, abort attaching.
+ listener.onStopRequest(aRequest, statusCode);
+ return;
+ }
+ var actions;
+ if (rangeRequest || streamRequest) {
+ actions = new RangedChromeActions(
+ domWindow,
+ contentDispositionFilename,
+ aRequest,
+ rangeRequest,
+ streamRequest,
+ dataListener
+ );
+ } else {
+ actions = new StandardChromeActions(
+ domWindow,
+ contentDispositionFilename,
+ aRequest,
+ dataListener
+ );
+ }
+ var requestListener = new RequestListener(actions);
+ domWindow.document.addEventListener(
+ PDFJS_EVENT_ID,
+ function (event) {
+ requestListener.receive(event);
+ },
+ false,
+ true
+ );
+
+ let actor = getActor(domWindow);
+ actor?.init(actions.supportsIntegratedFind());
+
+ listener.onStopRequest(aRequest, statusCode);
+ },
+ };
+
+ // Keep the URL the same so the browser sees it as the same.
+ channel.originalURI = aRequest.URI;
+ channel.loadGroup = aRequest.loadGroup;
+ channel.loadInfo.originAttributes = aRequest.loadInfo.originAttributes;
+
+ // We can use the resource principal when data is fetched by the chrome,
+ // e.g. useful for NoScript. Make make sure we reuse the origin attributes
+ // from the request channel to keep isolation consistent.
+ var uri = lazy.NetUtil.newURI(PDF_VIEWER_WEB_PAGE);
+ var resourcePrincipal =
+ Services.scriptSecurityManager.createContentPrincipal(
+ uri,
+ aRequest.loadInfo.originAttributes
+ );
+ // Remember the principal we would have had before we mess with it.
+ let originalPrincipal =
+ Services.scriptSecurityManager.getChannelResultPrincipal(aRequest);
+ aRequest.owner = resourcePrincipal;
+ aRequest.setProperty("noPDFJSPrincipal", originalPrincipal);
+
+ channel.asyncOpen(proxy);
+ },
+
+ // nsIRequestObserver::onStopRequest
+ onStopRequest(aRequest, aStatusCode) {
+ if (!this.dataListener) {
+ // Do nothing
+ return;
+ }
+
+ if (Components.isSuccessCode(aStatusCode)) {
+ this.dataListener.finish();
+ } else {
+ this.dataListener.error(aStatusCode);
+ }
+ delete this.dataListener;
+ delete this.binaryStream;
+ },
+};