summaryrefslogtreecommitdiffstats
path: root/toolkit/components/viewsource/content
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
commit36d22d82aa202bb199967e9512281e9a53db42c9 (patch)
tree105e8c98ddea1c1e4784a60a5a6410fa416be2de /toolkit/components/viewsource/content
parentInitial commit. (diff)
downloadfirefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz
firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip
Adding upstream version 115.7.0esr.upstream/115.7.0esr
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'toolkit/components/viewsource/content')
-rw-r--r--toolkit/components/viewsource/content/viewSourceUtils.js420
1 files changed, 420 insertions, 0 deletions
diff --git a/toolkit/components/viewsource/content/viewSourceUtils.js b/toolkit/components/viewsource/content/viewSourceUtils.js
new file mode 100644
index 0000000000..69d3eff287
--- /dev/null
+++ b/toolkit/components/viewsource/content/viewSourceUtils.js
@@ -0,0 +1,420 @@
+// -*- indent-tabs-mode: nil; js-indent-level: 2 -*-
+
+/* 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
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+ * To keep the global namespace safe, don't define global variables and
+ * functions in this file.
+ *
+ * This file silently depends on contentAreaUtils.js for getDefaultFileName
+ */
+
+ChromeUtils.defineESModuleGetters(this, {
+ PrivateBrowsingUtils: "resource://gre/modules/PrivateBrowsingUtils.sys.mjs",
+});
+
+var gViewSourceUtils = {
+ mnsIWebBrowserPersist: Ci.nsIWebBrowserPersist,
+ mnsIWebProgress: Ci.nsIWebProgress,
+ mnsIWebPageDescriptor: Ci.nsIWebPageDescriptor,
+
+ // Get the ViewSource actor for a browsing context.
+ getViewSourceActor(aBrowsingContext) {
+ return aBrowsingContext.currentWindowGlobal.getActor("ViewSource");
+ },
+
+ /**
+ * Get the ViewSourcePage actor.
+ * @param object An object with `browsingContext` field
+ */
+ getPageActor({ browsingContext }) {
+ return browsingContext.currentWindowGlobal.getActor("ViewSourcePage");
+ },
+
+ /**
+ * Opens the view source window.
+ *
+ * @param aArgs (required)
+ * This Object can include the following properties:
+ *
+ * URL (required):
+ * A string URL for the page we'd like to view the source of.
+ * browser (optional):
+ * The browser containing the document that we would like to view the
+ * source of. This is required if outerWindowID is passed.
+ * outerWindowID (optional):
+ * The outerWindowID of the content window containing the document that
+ * we want to view the source of. Pass this if you want to attempt to
+ * load the document source out of the network cache.
+ * lineNumber (optional):
+ * The line number to focus on once the source is loaded.
+ */
+ async viewSource(aArgs) {
+ // Check if external view source is enabled. If so, try it. If it fails,
+ // fallback to internal view source.
+ if (Services.prefs.getBoolPref("view_source.editor.external")) {
+ try {
+ await this.openInExternalEditor(aArgs);
+ return;
+ } catch (data) {}
+ }
+ // Try existing browsers first.
+ let browserWin = Services.wm.getMostRecentWindow("navigator:browser");
+ if (browserWin && browserWin.BrowserViewSourceOfDocument) {
+ browserWin.BrowserViewSourceOfDocument(aArgs);
+ return;
+ }
+ // No browser window created yet, try to create one.
+ let utils = this;
+ Services.ww.registerNotification(function onOpen(win, topic) {
+ if (
+ win.document.documentURI !== "about:blank" ||
+ topic !== "domwindowopened"
+ ) {
+ return;
+ }
+ Services.ww.unregisterNotification(onOpen);
+ win.addEventListener(
+ "load",
+ () => {
+ aArgs.viewSourceBrowser = win.gBrowser.selectedTab.linkedBrowser;
+ utils.viewSourceInBrowser(aArgs);
+ },
+ { once: true }
+ );
+ });
+ window.top.openWebLinkIn("about:blank", "current");
+ },
+
+ /**
+ * Displays view source in the provided <browser>. This allows for non-window
+ * display methods, such as a tab from Firefox.
+ *
+ * @param aArgs
+ * An object with the following properties:
+ *
+ * URL (required):
+ * A string URL for the page we'd like to view the source of.
+ * viewSourceBrowser (required):
+ * The browser to display the view source in.
+ * browser (optional):
+ * The browser containing the document that we would like to view the
+ * source of. This is required if outerWindowID is passed.
+ * outerWindowID (optional):
+ * The outerWindowID of the content window containing the document that
+ * we want to view the source of. Pass this if you want to attempt to
+ * load the document source out of the network cache.
+ * lineNumber (optional):
+ * The line number to focus on once the source is loaded.
+ */
+ viewSourceInBrowser({
+ URL,
+ viewSourceBrowser,
+ browser,
+ outerWindowID,
+ lineNumber,
+ }) {
+ if (!URL) {
+ throw new Error("Must supply a URL when opening view source.");
+ }
+
+ if (browser) {
+ // If we're dealing with a remote browser, then the browser
+ // for view source needs to be remote as well.
+ if (viewSourceBrowser.remoteType != browser.remoteType) {
+ // In this base case, where we are handed a <browser> someone else is
+ // managing, we don't know for sure that it's safe to toggle remoteness.
+ // For view source in a window, this is overridden to actually do the
+ // flip if needed.
+ throw new Error("View source browser's remoteness mismatch");
+ }
+ } else if (outerWindowID) {
+ throw new Error("Must supply the browser if passing the outerWindowID");
+ }
+
+ let viewSourceActor = this.getViewSourceActor(
+ viewSourceBrowser.browsingContext
+ );
+ viewSourceActor.sendAsyncMessage("ViewSource:LoadSource", {
+ URL,
+ outerWindowID,
+ lineNumber,
+ });
+ },
+
+ /**
+ * Displays view source for a selection from some document in the provided
+ * <browser>. This allows for non-window display methods, such as a tab from
+ * Firefox.
+ *
+ * @param aBrowsingContext:
+ * The child browsing context containing the document to view the source of.
+ * @param aGetBrowserFn
+ * A function that will return a browser to open the source in.
+ */
+ async viewPartialSourceInBrowser(aBrowsingContext, aGetBrowserFn) {
+ let sourceActor = this.getViewSourceActor(aBrowsingContext);
+ if (sourceActor) {
+ let data = await sourceActor.sendQuery("ViewSource:GetSelection", {});
+
+ let targetActor = this.getViewSourceActor(
+ aGetBrowserFn().browsingContext
+ );
+ targetActor.sendAsyncMessage("ViewSource:LoadSourceWithSelection", data);
+ }
+ },
+
+ buildEditorArgs(aPath, aLineNumber) {
+ // Determine the command line arguments to pass to the editor.
+ // We currently support a %LINE% placeholder which is set to the passed
+ // line number (or to 0 if there's none)
+ var editorArgs = [];
+ var args = Services.prefs.getCharPref("view_source.editor.args");
+ if (args) {
+ args = args.replace("%LINE%", aLineNumber || "0");
+ // add the arguments to the array (keeping quoted strings intact)
+ const argumentRE = /"([^"]+)"|(\S+)/g;
+ while (argumentRE.test(args)) {
+ editorArgs.push(RegExp.$1 || RegExp.$2);
+ }
+ }
+ editorArgs.push(aPath);
+ return editorArgs;
+ },
+
+ /**
+ * Opens an external editor with the view source content.
+ *
+ * @param aArgs (required)
+ * This Object can include the following properties:
+ *
+ * URL (required):
+ * A string URL for the page we'd like to view the source of.
+ * browser (optional):
+ * The browser containing the document that we would like to view the
+ * source of. This is required if outerWindowID is passed.
+ * outerWindowID (optional):
+ * The outerWindowID of the content window containing the document that
+ * we want to view the source of. Pass this if you want to attempt to
+ * load the document source out of the network cache.
+ * lineNumber (optional):
+ * The line number to focus on once the source is loaded.
+ *
+ * @return Promise
+ * The promise will be resolved or rejected based on whether the
+ * external editor attempt was successful. Either way, the data object
+ * is passed along as well.
+ */
+ openInExternalEditor(aArgs) {
+ return new Promise((resolve, reject) => {
+ let data;
+ let { URL, browser, lineNumber } = aArgs;
+ data = {
+ url: URL,
+ lineNumber,
+ isPrivate: false,
+ };
+ if (browser) {
+ data.doc = {
+ characterSet: browser.characterSet,
+ contentType: browser.documentContentType,
+ title: browser.contentTitle,
+ cookieJarSettings: browser.cookieJarSettings,
+ };
+ data.isPrivate = PrivateBrowsingUtils.isBrowserPrivate(browser);
+ }
+
+ try {
+ var editor = this.getExternalViewSourceEditor();
+ if (!editor) {
+ reject(data);
+ return;
+ }
+
+ // make a uri
+ var charset = data.doc ? data.doc.characterSet : null;
+ var uri = Services.io.newURI(data.url, charset);
+ data.uri = uri;
+
+ var path;
+ var contentType = data.doc ? data.doc.contentType : null;
+ var cookieJarSettings = data.doc ? data.doc.cookieJarSettings : null;
+ if (uri.scheme == "file") {
+ // it's a local file; we can open it directly
+ path = uri.QueryInterface(Ci.nsIFileURL).file.path;
+
+ var editorArgs = this.buildEditorArgs(path, data.lineNumber);
+ editor.runw(false, editorArgs, editorArgs.length);
+ resolve(data);
+ } else {
+ // set up the progress listener with what we know so far
+ this.viewSourceProgressListener.contentLoaded = false;
+ this.viewSourceProgressListener.editor = editor;
+ this.viewSourceProgressListener.resolve = resolve;
+ this.viewSourceProgressListener.reject = reject;
+ this.viewSourceProgressListener.data = data;
+
+ // without a page descriptor, loadPage has no chance of working. download the file.
+ var file = this.getTemporaryFile(uri, data.doc, contentType);
+ this.viewSourceProgressListener.file = file;
+
+ var webBrowserPersist = Cc[
+ "@mozilla.org/embedding/browser/nsWebBrowserPersist;1"
+ ].createInstance(this.mnsIWebBrowserPersist);
+ // the default setting is to not decode. we need to decode.
+ webBrowserPersist.persistFlags =
+ this.mnsIWebBrowserPersist.PERSIST_FLAGS_REPLACE_EXISTING_FILES;
+ webBrowserPersist.progressListener = this.viewSourceProgressListener;
+ let ssm = Services.scriptSecurityManager;
+ let principal = ssm.createContentPrincipal(
+ data.uri,
+ browser.contentPrincipal.originAttributes
+ );
+ webBrowserPersist.saveURI(
+ uri,
+ principal,
+ null,
+ null,
+ cookieJarSettings,
+ null,
+ null,
+ file,
+ Ci.nsIContentPolicy.TYPE_SAVEAS_DOWNLOAD,
+ data.isPrivate
+ );
+
+ let helperService = Cc[
+ "@mozilla.org/uriloader/external-helper-app-service;1"
+ ].getService(Ci.nsPIExternalAppLauncher);
+ if (data.isPrivate) {
+ // register the file to be deleted when possible
+ helperService.deleteTemporaryPrivateFileWhenPossible(file);
+ } else {
+ // register the file to be deleted on app exit
+ helperService.deleteTemporaryFileOnExit(file);
+ }
+ }
+ } catch (ex) {
+ // we failed loading it with the external editor.
+ console.error(ex);
+ reject(data);
+ }
+ });
+ },
+
+ // Returns nsIProcess of the external view source editor or null
+ getExternalViewSourceEditor() {
+ try {
+ let viewSourceAppPath = Services.prefs.getComplexValue(
+ "view_source.editor.path",
+ Ci.nsIFile
+ );
+ let editor = Cc["@mozilla.org/process/util;1"].createInstance(
+ Ci.nsIProcess
+ );
+ editor.init(viewSourceAppPath);
+
+ return editor;
+ } catch (ex) {
+ console.error(ex);
+ }
+
+ return null;
+ },
+
+ viewSourceProgressListener: {
+ mnsIWebProgressListener: Ci.nsIWebProgressListener,
+
+ QueryInterface: ChromeUtils.generateQI([
+ "nsIWebProgressListener",
+ "nsISupportsWeakReference",
+ ]),
+
+ destroy() {
+ this.editor = null;
+ this.resolve = null;
+ this.reject = null;
+ this.data = null;
+ this.file = null;
+ },
+
+ // This listener is used both for tracking the progress of an HTML parse
+ // in one case and for tracking the progress of nsIWebBrowserPersist in
+ // another case.
+ onStateChange(aProgress, aRequest, aFlag, aStatus) {
+ // once it's done loading...
+ if (aFlag & this.mnsIWebProgressListener.STATE_STOP && aStatus == 0) {
+ // We aren't waiting for the parser. Instead, we are waiting for
+ // an nsIWebBrowserPersist.
+ this.onContentLoaded();
+ }
+ return 0;
+ },
+
+ onContentLoaded() {
+ // The progress listener may call this multiple times, so be sure we only
+ // run once.
+ if (this.contentLoaded) {
+ return;
+ }
+ try {
+ if (!this.file) {
+ throw new Error("View-source progress listener should have a file!");
+ }
+
+ var editorArgs = gViewSourceUtils.buildEditorArgs(
+ this.file.path,
+ this.data.lineNumber
+ );
+ this.editor.runw(false, editorArgs, editorArgs.length);
+
+ this.contentLoaded = true;
+ this.resolve(this.data);
+ } catch (ex) {
+ // we failed loading it with the external editor.
+ console.error(ex);
+ this.reject(this.data);
+ } finally {
+ this.destroy();
+ }
+ },
+
+ editor: null,
+ resolve: null,
+ reject: null,
+ data: null,
+ file: null,
+ },
+
+ // returns an nsIFile for the passed document in the system temp directory
+ getTemporaryFile(aURI, aDocument, aContentType) {
+ // include contentAreaUtils.js in our own context when we first need it
+ if (!this._caUtils) {
+ this._caUtils = {};
+ Services.scriptloader.loadSubScript(
+ "chrome://global/content/contentAreaUtils.js",
+ this._caUtils
+ );
+ }
+
+ var fileName = this._caUtils.getDefaultFileName(
+ null,
+ aURI,
+ aDocument,
+ null
+ );
+
+ const mimeService = Cc["@mozilla.org/mime;1"].getService(Ci.nsIMIMEService);
+ fileName = mimeService.validateFileNameForSaving(
+ fileName,
+ aContentType,
+ mimeService.VALIDATE_DEFAULT
+ );
+
+ var tempFile = Services.dirsvc.get("TmpD", Ci.nsIFile);
+ tempFile.append(fileName);
+ return tempFile;
+ },
+};