diff options
Diffstat (limited to '')
19 files changed, 1435 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..cf3093f255 --- /dev/null +++ b/toolkit/components/viewsource/content/viewSourceUtils.js @@ -0,0 +1,419 @@ +// -*- 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.savePrivacyAwareURI( + 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. + Cu.reportError(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) { + Cu.reportError(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. + Cu.reportError(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; + }, +}; diff --git a/toolkit/components/viewsource/jar.mn b/toolkit/components/viewsource/jar.mn new file mode 100644 index 0000000000..e483f3080a --- /dev/null +++ b/toolkit/components/viewsource/jar.mn @@ -0,0 +1,6 @@ +# 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/. + +toolkit.jar: + content/global/viewSourceUtils.js (content/viewSourceUtils.js) diff --git a/toolkit/components/viewsource/moz.build b/toolkit/components/viewsource/moz.build new file mode 100644 index 0000000000..1f13fe6e56 --- /dev/null +++ b/toolkit/components/viewsource/moz.build @@ -0,0 +1,13 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# 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/. + +BROWSER_CHROME_MANIFESTS += ["test/browser/browser.ini"] +MOCHITEST_CHROME_MANIFESTS += ["test/chrome.ini"] + +JAR_MANIFESTS += ["jar.mn"] + +with Files("**"): + BUG_COMPONENT = ("Toolkit", "View Source") diff --git a/toolkit/components/viewsource/test/browser/browser.ini b/toolkit/components/viewsource/test/browser/browser.ini new file mode 100644 index 0000000000..4ac477c7c1 --- /dev/null +++ b/toolkit/components/viewsource/test/browser/browser.ini @@ -0,0 +1,22 @@ +[DEFAULT] +support-files = head.js + file_bug464222.html + +[browser_bug464222.js] +https_first_disabled = true +[browser_viewsource_newwindow.js] +https_first_disabled = true +[browser_bug713810.js] +[browser_contextmenu.js] +skip-if = + os == "win" && processor == "aarch64" # disabled on aarch64 due to 1531590 + fission && os == "mac" && !debug # Bug 1713913 - new Fission platform triage +[browser_gotoline.js] +[browser_open_docgroup.js] +[browser_partialsource.js] +skip-if = + fission && os == "mac" && !debug # Bug 1713913 - new Fission platform triage +[browser_srcdoc.js] +[browser_validatefilename.js] +[browser_viewsourceprefs.js] +skip-if = socketprocess_networking && os == "linux" && !debug diff --git a/toolkit/components/viewsource/test/browser/browser_bug464222.js b/toolkit/components/viewsource/test/browser/browser_bug464222.js new file mode 100644 index 0000000000..7a702c2851 --- /dev/null +++ b/toolkit/components/viewsource/test/browser/browser_bug464222.js @@ -0,0 +1,17 @@ +const source = + "http://example.com/browser/toolkit/components/viewsource/test/browser/file_bug464222.html"; + +add_task(async function() { + let viewSourceTab = await openDocumentSelect(source, "a"); + + let href = await SpecialPowers.spawn( + viewSourceTab.linkedBrowser, + [], + async function() { + return content.document.querySelectorAll("a[href]")[0].href; + } + ); + + is(href, "view-source:" + source, "Relative links broken?"); + gBrowser.removeTab(viewSourceTab); +}); diff --git a/toolkit/components/viewsource/test/browser/browser_bug713810.js b/toolkit/components/viewsource/test/browser/browser_bug713810.js new file mode 100644 index 0000000000..bfae83e699 --- /dev/null +++ b/toolkit/components/viewsource/test/browser/browser_bug713810.js @@ -0,0 +1,31 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +const source = + '<html xmlns="http://www.w3.org/1999/xhtml"><body><p>This is a paragraph.</p></body></html>'; + +add_task(async function() { + let viewSourceTab = await openDocumentSelect("data:text/html," + source, "p"); + await SpecialPowers.spawn(viewSourceTab.linkedBrowser, [], async function() { + Assert.equal( + content.document.body.textContent, + "<p>This is a paragraph.</p>", + "Correct source for text/html" + ); + }); + gBrowser.removeTab(viewSourceTab); + + viewSourceTab = await openDocumentSelect( + "data:application/xhtml+xml," + source, + "p" + ); + await SpecialPowers.spawn(viewSourceTab.linkedBrowser, [], async function() { + Assert.equal( + content.document.body.textContent, + '<p xmlns="http://www.w3.org/1999/xhtml">This is a paragraph.</p>', + "Correct source for application/xhtml+xml" + ); + }); + gBrowser.removeTab(viewSourceTab); +}); diff --git a/toolkit/components/viewsource/test/browser/browser_contextmenu.js b/toolkit/components/viewsource/test/browser/browser_contextmenu.js new file mode 100644 index 0000000000..8177c721a2 --- /dev/null +++ b/toolkit/components/viewsource/test/browser/browser_contextmenu.js @@ -0,0 +1,115 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +var source = + "data:text/html,text<link%20href='http://example.com/'%20/>more%20text<a%20href='mailto:abc@def.ghi'>email</a>"; +var gViewSourceWindow, gContextMenu, gCopyLinkMenuItem, gCopyEmailMenuItem; + +var expectedData = []; + +add_task(async function() { + // Full source in view source tab + let newTab = await openDocument(source); + await onViewSourceWindowOpen(window); + + let contextMenu = document.getElementById("contentAreaContextMenu"); + + for (let test of expectedData) { + await checkMenuItems(contextMenu, test[0], test[1], test[2], test[3]); + } + + gBrowser.removeTab(newTab); + + // Selection source in view source tab + expectedData = []; + newTab = await openDocumentSelect(source, "body"); + await onViewSourceWindowOpen(window); + + contextMenu = document.getElementById("contentAreaContextMenu"); + + for (let test of expectedData) { + await checkMenuItems(contextMenu, test[0], test[1], test[2], test[3]); + } + + gBrowser.removeTab(newTab); +}); + +async function onViewSourceWindowOpen(aWindow) { + gViewSourceWindow = aWindow; + + gCopyLinkMenuItem = aWindow.document.getElementById("context-copylink"); + gCopyEmailMenuItem = aWindow.document.getElementById("context-copyemail"); + + let browser = gBrowser.selectedBrowser; + await SpecialPowers.spawn(browser, [], async function(arg) { + let tags = content.document.querySelectorAll("a[href]"); + Assert.equal( + tags[0].href, + "view-source:http://example.com/", + "Link has correct href" + ); + Assert.equal(tags[1].href, "mailto:abc@def.ghi", "Link has correct href"); + }); + + expectedData.push(["a[href]", true, false, "http://example.com/"]); + expectedData.push(["a[href^=mailto]", false, true, "abc@def.ghi"]); + expectedData.push(["span", false, false, null]); +} + +async function checkMenuItems( + contextMenu, + selector, + copyLinkExpected, + copyEmailExpected, + expectedClipboardContent +) { + let browser = gBrowser.selectedBrowser; + await SpecialPowers.spawn(browser, [{ selector }], async function(arg) { + content.document.querySelector(arg.selector).scrollIntoView(); + }); + + let popupShownPromise = BrowserTestUtils.waitForEvent( + contextMenu, + "popupshown" + ); + await BrowserTestUtils.synthesizeMouseAtCenter( + selector, + { type: "contextmenu", button: 2 }, + browser + ); + await popupShownPromise; + + is( + gCopyLinkMenuItem.hidden, + !copyLinkExpected, + "Copy link menuitem is " + (copyLinkExpected ? "not hidden" : "hidden") + ); + is( + gCopyEmailMenuItem.hidden, + !copyEmailExpected, + "Copy email menuitem is " + (copyEmailExpected ? "not hidden" : "hidden") + ); + + if (copyLinkExpected || copyEmailExpected) { + await new Promise((resolve, reject) => { + waitForClipboard( + expectedClipboardContent, + function() { + contextMenu.activateItem( + copyLinkExpected ? gCopyLinkMenuItem : gCopyEmailMenuItem + ); + }, + resolve, + reject + ); + }); + } else { + let popupHiddenPromise = BrowserTestUtils.waitForEvent( + contextMenu, + "popuphidden" + ); + contextMenu.hidePopup(); + await popupHiddenPromise; + } +} diff --git a/toolkit/components/viewsource/test/browser/browser_gotoline.js b/toolkit/components/viewsource/test/browser/browser_gotoline.js new file mode 100644 index 0000000000..480d2eebd0 --- /dev/null +++ b/toolkit/components/viewsource/test/browser/browser_gotoline.js @@ -0,0 +1,41 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +const { ContentTaskUtils } = ChromeUtils.importESModule( + "resource://testing-common/ContentTaskUtils.sys.mjs" +); + +var content = "line 1\nline 2\nline 3"; + +add_task(async function() { + // First test with text with the text/html mimetype. + let tab = await openDocument("data:text/html," + encodeURIComponent(content)); + await checkViewSource(tab); + gBrowser.removeTab(tab); + + tab = await openDocument("data:text/plain," + encodeURIComponent(content)); + await checkViewSource(tab); + gBrowser.removeTab(tab); +}); + +var checkViewSource = async function(aTab) { + let browser = aTab.linkedBrowser; + await SpecialPowers.spawn(browser, [content], async function(text) { + is(content.document.body.textContent, text, "Correct content loaded"); + }); + + for (let i = 1; i <= 3; i++) { + browser.sendMessageToActor( + "ViewSource:GoToLine", + { + lineNumber: i, + }, + "ViewSourcePage" + ); + await SpecialPowers.spawn(browser, [i], async function(i) { + let selection = content.getSelection(); + Assert.equal(selection.toString(), "line " + i, "Correct text selected"); + }); + } +}; diff --git a/toolkit/components/viewsource/test/browser/browser_open_docgroup.js b/toolkit/components/viewsource/test/browser/browser_open_docgroup.js new file mode 100644 index 0000000000..f9d2490fea --- /dev/null +++ b/toolkit/components/viewsource/test/browser/browser_open_docgroup.js @@ -0,0 +1,41 @@ +"use strict"; + +/** + * Very basic smoketests for the View Source feature, which also + * forces on the DocGroup mismatch check that was added in + * bug 1340719. + */ + +add_setup(async function() { + await SpecialPowers.pushPrefEnv({ + set: [["extensions.throw_on_docgroup_mismatch.enabled", true]], + }); +}); + +/** + * Tests that we can open View Source in a tab. + */ +add_task(async function test_view_source_in_tab() { + await BrowserTestUtils.withNewTab( + { + gBrowser, + url: "http://example.com", + }, + async function(browser) { + let sourceTab = await openViewSourceForBrowser(browser); + let sourceBrowser = sourceTab.linkedBrowser; + + await SpecialPowers.spawn(sourceBrowser, [], async function() { + Assert.equal( + content.document.body.id, + "viewsource", + "View source mode enabled" + ); + }); + + BrowserTestUtils.removeTab(sourceTab); + } + ); + + await SpecialPowers.popPrefEnv(); +}); diff --git a/toolkit/components/viewsource/test/browser/browser_partialsource.js b/toolkit/components/viewsource/test/browser/browser_partialsource.js new file mode 100644 index 0000000000..5efdc1c1cc --- /dev/null +++ b/toolkit/components/viewsource/test/browser/browser_partialsource.js @@ -0,0 +1,46 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +const frameSource = + "<a href='about:mozilla'>some text</a><a id='other' href='about:about'>other text</a>"; +const sources = [ + `<html><iframe id="f" srcdoc="${frameSource}"></iframe></html>`, + `<html><iframe id="f" src="https://example.com/document-builder.sjs?html=${frameSource}"></iframe></html>`, +]; + +add_task(async function partial_source() { + for (let source of sources) { + let tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + "data:text/html," + source + ); + + let frameBC = gBrowser.selectedBrowser.browsingContext.children[0]; + + await SpecialPowers.spawn(frameBC, [], () => { + let element = content.document.getElementById("other"); + content.focus(); + content.getSelection().selectAllChildren(element); + }); + + let sourceTab = await openViewPartialSource("#other", frameBC); + + let browser = gBrowser.selectedBrowser; + let textContent = await SpecialPowers.spawn(browser, [], async function() { + return content.document.body.textContent; + }); + is( + textContent, + '<a id="other" href="about:about">other text</a>', + "Correct content loaded" + ); + let selection = await SpecialPowers.spawn(browser, [], async function() { + return String(content.getSelection()); + }); + is(selection, "other text", "Correct text selected"); + + gBrowser.removeTab(sourceTab); + gBrowser.removeTab(tab); + } +}); diff --git a/toolkit/components/viewsource/test/browser/browser_srcdoc.js b/toolkit/components/viewsource/test/browser/browser_srcdoc.js new file mode 100644 index 0000000000..6486a5b4f7 --- /dev/null +++ b/toolkit/components/viewsource/test/browser/browser_srcdoc.js @@ -0,0 +1,28 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +const frameSource = `<a href="about:mozilla">good</a>`; +const source = `<html><iframe srcdoc='${frameSource}' id="f"></iframe></html>`; + +add_task(async function() { + let url = `data:text/html,${source}`; + await BrowserTestUtils.withNewTab({ gBrowser, url }, checkFrameSource); +}); + +async function checkFrameSource() { + let sourceTab = await openViewFrameSourceTab("#f"); + registerCleanupFunction(function() { + gBrowser.removeTab(sourceTab); + }); + + let browser = gBrowser.selectedBrowser; + let textContent = await SpecialPowers.spawn(browser, [], async function() { + return content.document.body.textContent; + }); + is(textContent, frameSource, "Correct content loaded"); + let id = await SpecialPowers.spawn(browser, [], async function() { + return content.document.body.id; + }); + is(id, "viewsource", "View source mode enabled"); +} diff --git a/toolkit/components/viewsource/test/browser/browser_validatefilename.js b/toolkit/components/viewsource/test/browser/browser_validatefilename.js new file mode 100644 index 0000000000..cd99f1c57e --- /dev/null +++ b/toolkit/components/viewsource/test/browser/browser_validatefilename.js @@ -0,0 +1,68 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +add_task(async function() { + let tests = [ + { + uri: "data:text/html,Test", + basename: "index", + }, + { + uri: "data:text/html,<title>Hello There</title>Test", + basename: "Hello There", + }, + ]; + + for (let test of tests) { + await BrowserTestUtils.withNewTab(test.uri, async browser => { + let doc = { + characterSet: browser.characterSet, + contentType: browser.documentContentType, + title: browser.contentTitle, + }; + + let fl = gViewSourceUtils.getTemporaryFile( + browser.currentURI, + doc, + "text/html" + ); + // Some versions of Windows will crop the extension to three characters so allow both forms. + ok( + fl.leafName == test.basename + ".htm" || + fl.leafName == test.basename + ".html", + "filename title for " + test.basename + " html" + ); + + doc.contentType = "application/xhtml+xml"; + fl = gViewSourceUtils.getTemporaryFile( + browser.currentURI, + doc, + "application/xhtml+xml" + ); + ok( + fl.leafName == test.basename + ".xht" || + fl.leafName == test.basename + ".xhtml", + "filename title for " + test.basename + " xhtml" + ); + }); + } + + let fl = gViewSourceUtils.getTemporaryFile( + Services.io.newURI("http://www.example.com/simple"), + null, + "text/html" + ); + ok( + fl.leafName == "simple.htm" || fl.leafName == "simple.html", + "filename title for simple" + ); + + fl = gViewSourceUtils.getTemporaryFile( + Services.io.newURI("http://www.example.com/samplefile.txt"), + null, + "text/html" + ); + is(fl.leafName, "samplefile.txt", "filename title for samplefile"); +}); diff --git a/toolkit/components/viewsource/test/browser/browser_viewsource_newwindow.js b/toolkit/components/viewsource/test/browser/browser_viewsource_newwindow.js new file mode 100644 index 0000000000..7afde07def --- /dev/null +++ b/toolkit/components/viewsource/test/browser/browser_viewsource_newwindow.js @@ -0,0 +1,100 @@ +/** + * Waits for a View Source window to be opened at a particular + * URL. + * + * @param {string} expectedURL The view-source: URL that's expected. + * @resolves {DOM Window} The window that was opened. + * @returns {Promise} + */ +async function waitForNewViewSourceWindow(expectedURL) { + let win = await BrowserTestUtils.domWindowOpened(); + await BrowserTestUtils.waitForEvent(win, "EndSwapDocShells", true); + let browser = win.gBrowser.selectedBrowser; + if (browser.currentURI.spec != expectedURL) { + await BrowserTestUtils.browserLoaded(browser, false, expectedURL); + } + return win; +} + +/** + * When view_source.tab is set to false, view source should + * open in new browser window instead of new tab. + */ +add_task(async function() { + await SpecialPowers.pushPrefEnv({ + set: [["view_source.tab", false]], + }); + + const PAGE = "http://example.com/"; + await BrowserTestUtils.withNewTab( + { + url: PAGE, + gBrowser, + }, + async browser => { + let winPromise = waitForNewViewSourceWindow("view-source:" + PAGE); + BrowserViewSource(browser); + let win = await winPromise; + + ok(win, "View Source opened up in a new window."); + await BrowserTestUtils.closeWindow(win); + } + ); +}); + +/** + * When view_source.tab is set to false, view partial source + * should open up in new browser window instead of new tab. + */ +add_task(async function() { + await SpecialPowers.pushPrefEnv({ + set: [["view_source.tab", false]], + }); + + const para = "<p>test</p>"; + const source = `<html><body>${para}</body></html>`; + await BrowserTestUtils.withNewTab( + { + url: "data:text/html," + source, + gBrowser, + }, + async browser => { + let winPromise = waitForNewViewSourceWindow( + "view-source:data:text/html;charset=utf-8,%3Cp%3E%EF%B7%90test%EF%B7%AF%3C%2Fp%3E" + ); + await SpecialPowers.spawn(gBrowser.selectedBrowser, [], async function( + arg + ) { + let element = content.document.querySelector("p"); + content.getSelection().selectAllChildren(element); + }); + + let contentAreaContextMenuPopup = document.getElementById( + "contentAreaContextMenu" + ); + let popupShownPromise = BrowserTestUtils.waitForEvent( + contentAreaContextMenuPopup, + "popupshown" + ); + await BrowserTestUtils.synthesizeMouseAtCenter( + "p", + { type: "contextmenu", button: 2 }, + gBrowser.selectedBrowser + ); + await popupShownPromise; + + let popupHiddenPromise = BrowserTestUtils.waitForEvent( + contentAreaContextMenuPopup, + "popuphidden" + ); + let item = document.getElementById("context-viewpartialsource-selection"); + contentAreaContextMenuPopup.activateItem(item); + await popupHiddenPromise; + dump("Before winPromise"); + let win = await winPromise; + dump("After winPromise"); + ok(win, "View Partial Source opened up in a new window."); + await BrowserTestUtils.closeWindow(win); + } + ); +}); diff --git a/toolkit/components/viewsource/test/browser/browser_viewsourceprefs.js b/toolkit/components/viewsource/test/browser/browser_viewsourceprefs.js new file mode 100644 index 0000000000..5d7c22832c --- /dev/null +++ b/toolkit/components/viewsource/test/browser/browser_viewsourceprefs.js @@ -0,0 +1,203 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +var plaintextURL = "data:text/plain,hello+world"; +var htmlURL = "about:mozilla"; + +add_setup(async function() { + registerCleanupFunction(function() { + SpecialPowers.clearUserPref("view_source.tab_size"); + SpecialPowers.clearUserPref("view_source.wrap_long_lines"); + SpecialPowers.clearUserPref("view_source.syntax_highlight"); + }); +}); + +add_task(async function() { + await exercisePrefs(plaintextURL, false); + await exercisePrefs(htmlURL, true); +}); + +const contextMenu = document.getElementById("contentAreaContextMenu"); +async function openContextMenu(browser) { + info("Opening context menu"); + const popupShownPromise = BrowserTestUtils.waitForEvent( + contextMenu, + "popupshown" + ); + await BrowserTestUtils.synthesizeMouseAtCenter( + "html", + { type: "contextmenu", button: 2 }, + browser + ); + await popupShownPromise; + info("Opened context menu"); +} + +async function closeContextMenu() { + const popupHiddenPromise = BrowserTestUtils.waitForEvent( + contextMenu, + "popuphidden" + ); + contextMenu.hidePopup(); + await popupHiddenPromise; +} + +async function simulateClick(id) { + const popupHiddenPromise = BrowserTestUtils.waitForEvent( + contextMenu, + "popuphidden" + ); + contextMenu.activateItem(document.getElementById(id)); + await popupHiddenPromise; +} + +function getAttribute(id, attribute) { + let item = document.getElementById(id); + return item.getAttribute(attribute); +} + +var exercisePrefs = async function(source, highlightable) { + let tab = await openDocument(source); + let browser = tab.linkedBrowser; + + const wrapMenuItem = "context-viewsource-wrapLongLines"; + const syntaxMenuItem = "context-viewsource-highlightSyntax"; + + // Test the default states of these menu items. + await checkStyle(browser, "-moz-tab-size", 4); + await openContextMenu(browser); + await checkStyle(browser, "white-space", "pre"); + await checkHighlight(browser, highlightable); + is( + getAttribute(wrapMenuItem, "checked"), + "false", + "Wrap menu item not checked by default" + ); + is( + getAttribute(syntaxMenuItem, "checked"), + "true", + "Syntax menu item checked by default" + ); + await closeContextMenu(); + + // Next, test that the Wrap Long Lines menu item works. + let prefReady = waitForPrefChange("view_source.wrap_long_lines"); + await openContextMenu(browser); + await simulateClick(wrapMenuItem); + await openContextMenu(browser); + await checkStyle(browser, "white-space", "pre-wrap"); + is(getAttribute(wrapMenuItem, "checked"), "true", "Wrap menu item checked"); + await prefReady; + is( + SpecialPowers.getBoolPref("view_source.wrap_long_lines"), + true, + "Wrap pref set" + ); + await closeContextMenu(); + + prefReady = waitForPrefChange("view_source.wrap_long_lines"); + await openContextMenu(browser); + await simulateClick(wrapMenuItem); + await openContextMenu(browser); + await checkStyle(browser, "white-space", "pre"); + is( + getAttribute(wrapMenuItem, "checked"), + "false", + "Wrap menu item unchecked" + ); + await prefReady; + is( + SpecialPowers.getBoolPref("view_source.wrap_long_lines"), + false, + "Wrap pref set" + ); + await closeContextMenu(); + + // Check that the Syntax Highlighting menu item works. + prefReady = waitForPrefChange("view_source.syntax_highlight"); + await openContextMenu(browser); + await simulateClick(syntaxMenuItem); + await openContextMenu(browser); + await checkHighlight(browser, false); + is( + getAttribute(syntaxMenuItem, "checked"), + "false", + "Syntax menu item unchecked" + ); + await prefReady; + is( + SpecialPowers.getBoolPref("view_source.syntax_highlight"), + false, + "Syntax highlighting pref set" + ); + await closeContextMenu(); + + prefReady = waitForPrefChange("view_source.syntax_highlight"); + await openContextMenu(browser); + await simulateClick(syntaxMenuItem); + await openContextMenu(browser); + await checkHighlight(browser, highlightable); + is( + getAttribute(syntaxMenuItem, "checked"), + "true", + "Syntax menu item checked" + ); + await prefReady; + is( + SpecialPowers.getBoolPref("view_source.syntax_highlight"), + true, + "Syntax highlighting pref set" + ); + await closeContextMenu(); + gBrowser.removeTab(tab); + + // Open a new view-source window to check that the prefs are obeyed. + SpecialPowers.setIntPref("view_source.tab_size", 2); + SpecialPowers.setBoolPref("view_source.wrap_long_lines", true); + SpecialPowers.setBoolPref("view_source.syntax_highlight", false); + + tab = await openDocument(source); + browser = tab.linkedBrowser; + + await checkStyle(browser, "-moz-tab-size", 2); + await openContextMenu(browser); + await checkStyle(browser, "white-space", "pre-wrap"); + await checkHighlight(browser, false); + is(getAttribute(wrapMenuItem, "checked"), "true", "Wrap menu item checked"); + is( + getAttribute(syntaxMenuItem, "checked"), + "false", + "Syntax menu item unchecked" + ); + + SpecialPowers.clearUserPref("view_source.tab_size"); + SpecialPowers.clearUserPref("view_source.wrap_long_lines"); + SpecialPowers.clearUserPref("view_source.syntax_highlight"); + + await closeContextMenu(); + gBrowser.removeTab(tab); +}; + +var checkStyle = async function(browser, styleProperty, expected) { + let value = await SpecialPowers.spawn( + browser, + [styleProperty], + async function(styleProperty) { + let style = content.getComputedStyle(content.document.body); + return style.getPropertyValue(styleProperty); + } + ); + is(value, "" + expected, "Correct value of " + styleProperty); +}; + +var checkHighlight = async function(browser, expected) { + let highlighted = await SpecialPowers.spawn(browser, [], async function() { + let spans = content.document.getElementsByTagName("span"); + return Array.prototype.some.call(spans, span => { + let style = content.getComputedStyle(span); + return style.getPropertyValue("color") !== "rgb(0, 0, 0)"; + }); + }); + is(highlighted, expected, "Syntax highlighting " + (expected ? "on" : "off")); +}; diff --git a/toolkit/components/viewsource/test/browser/file_bug464222.html b/toolkit/components/viewsource/test/browser/file_bug464222.html new file mode 100644 index 0000000000..f3b00949c7 --- /dev/null +++ b/toolkit/components/viewsource/test/browser/file_bug464222.html @@ -0,0 +1 @@ +<a href="file_bug464222.html">I'm a link</a> diff --git a/toolkit/components/viewsource/test/browser/head.js b/toolkit/components/viewsource/test/browser/head.js new file mode 100644 index 0000000000..f76f8c1853 --- /dev/null +++ b/toolkit/components/viewsource/test/browser/head.js @@ -0,0 +1,234 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +var { PromiseUtils } = ChromeUtils.importESModule( + "resource://gre/modules/PromiseUtils.sys.mjs" +); +const { Preferences } = ChromeUtils.importESModule( + "resource://gre/modules/Preferences.sys.mjs" +); + +/** + * Wait for view source tab after calling given function to open it. + * + * @param open - a function to open view source. + * @returns the new tab which shows the source. + */ +async function waitForViewSourceTab(open) { + let sourceLoadedPromise; + let tabPromise; + + tabPromise = new Promise(resolve => { + gBrowser.tabContainer.addEventListener( + "TabOpen", + event => { + let tab = event.target; + sourceLoadedPromise = waitForSourceLoaded(tab); + resolve(tab); + }, + { once: true } + ); + }); + + await open(); + + let tab = await tabPromise; + await sourceLoadedPromise; + return tab; +} + +/** + * Opens view source for a browser. + * + * @param browser - the <xul:browser> to open view source for. + * @returns the new tab which shows the source. + */ +function openViewSourceForBrowser(browser) { + return waitForViewSourceTab(() => { + window.BrowserViewSource(browser); + }); +} + +/** + * Opens a view source tab. (View Source) + * within the currently selected browser in gBrowser. + * + * @returns the new tab which shows the source. + */ +async function openViewSource() { + let contentAreaContextMenuPopup = document.getElementById( + "contentAreaContextMenu" + ); + let popupShownPromise = BrowserTestUtils.waitForEvent( + contentAreaContextMenuPopup, + "popupshown" + ); + await BrowserTestUtils.synthesizeMouseAtCenter( + "body", + { type: "contextmenu", button: 2 }, + gBrowser.selectedBrowser + ); + await popupShownPromise; + + return waitForViewSourceTab(async () => { + let popupHiddenPromise = BrowserTestUtils.waitForEvent( + contentAreaContextMenuPopup, + "popuphidden" + ); + contentAreaContextMenuPopup.activateItem( + document.getElementById("context-viewsource") + ); + await popupHiddenPromise; + }); +} + +/** + * Opens a view source tab for a selection (View Selection Source) + * within the currently selected browser in gBrowser. + * + * @param aCSSSelector - used to specify a node within the selection to + * view the source of. It is expected that this node is + * within an existing selection. + * @param aBrowsingContext - browsing context containing a subframe (optional). + * @returns the new tab which shows the source. + */ +async function openViewPartialSource( + aCSSSelector, + aBrowsingContext = gBrowser.selectedBrowser +) { + let contentAreaContextMenuPopup = document.getElementById( + "contentAreaContextMenu" + ); + let popupShownPromise = BrowserTestUtils.waitForEvent( + contentAreaContextMenuPopup, + "popupshown" + ); + await BrowserTestUtils.synthesizeMouseAtCenter( + aCSSSelector, + { type: "contextmenu", button: 2 }, + aBrowsingContext + ); + await popupShownPromise; + + return waitForViewSourceTab(async () => { + let popupHiddenPromise = BrowserTestUtils.waitForEvent( + contentAreaContextMenuPopup, + "popuphidden" + ); + let item = document.getElementById("context-viewpartialsource-selection"); + contentAreaContextMenuPopup.activateItem(item); + await popupHiddenPromise; + }); +} + +/** + * Opens a view source tab for a frame (View Frame Source) within the + * currently selected browser in gBrowser. + * + * @param aCSSSelector - used to specify the frame to view the source of. + * @returns the new tab which shows the source. + */ +async function openViewFrameSourceTab(aCSSSelector) { + let contentAreaContextMenuPopup = document.getElementById( + "contentAreaContextMenu" + ); + let popupShownPromise = BrowserTestUtils.waitForEvent( + contentAreaContextMenuPopup, + "popupshown" + ); + await BrowserTestUtils.synthesizeMouseAtCenter( + aCSSSelector, + { type: "contextmenu", button: 2 }, + gBrowser.selectedBrowser + ); + await popupShownPromise; + + let frameContextMenu = document.getElementById("frame"); + popupShownPromise = BrowserTestUtils.waitForEvent( + frameContextMenu, + "popupshown" + ); + frameContextMenu.openMenu(true); + await popupShownPromise; + + return waitForViewSourceTab(async () => { + let popupHiddenPromise = BrowserTestUtils.waitForEvent( + frameContextMenu, + "popuphidden" + ); + let item = document.getElementById("context-viewframesource"); + frameContextMenu.menupopup.activateItem(item); + await popupHiddenPromise; + }); +} + +/** + * For a given view source tab, wait for the source loading step to + * complete. + */ +function waitForSourceLoaded(tab) { + return BrowserTestUtils.waitForContentEvent( + tab.linkedBrowser, + "pageshow", + false, + event => String(event.target.location).startsWith("view-source") + ); +} + +/** + * Open a new document in a new tab, select part of it, and view the source of + * that selection. The document is not closed afterwards. + * + * @param aURI - url to load + * @param aCSSSelector - used to specify a node to select. All of this node's + * children will be selected. + * @returns the new tab which shows the source. + */ +async function openDocumentSelect(aURI, aCSSSelector) { + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, aURI); + registerCleanupFunction(function() { + gBrowser.removeTab(tab); + }); + + await SpecialPowers.spawn( + gBrowser.selectedBrowser, + [{ selector: aCSSSelector }], + async function(arg) { + let element = content.document.querySelector(arg.selector); + content.getSelection().selectAllChildren(element); + } + ); + + return openViewPartialSource(aCSSSelector); +} + +/** + * Open a new document in a new tab and view the source of whole page. + * The document is not closed afterwards. + * + * @param aURI - url to load + * @returns the new tab which shows the source. + */ +async function openDocument(aURI) { + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, aURI); + registerCleanupFunction(function() { + gBrowser.removeTab(tab); + }); + + return openViewSource(); +} + +function pushPrefs(...aPrefs) { + return SpecialPowers.pushPrefEnv({ set: aPrefs }); +} + +function waitForPrefChange(pref) { + let deferred = PromiseUtils.defer(); + let observer = () => { + Preferences.ignore(pref, observer); + deferred.resolve(); + }; + Preferences.observe(pref, observer); + return deferred.promise; +} diff --git a/toolkit/components/viewsource/test/chrome.ini b/toolkit/components/viewsource/test/chrome.ini new file mode 100644 index 0000000000..bd013ab6c9 --- /dev/null +++ b/toolkit/components/viewsource/test/chrome.ini @@ -0,0 +1,4 @@ +[DEFAULT] + +[test_bug428653.html] +support-files = file_empty.html diff --git a/toolkit/components/viewsource/test/file_empty.html b/toolkit/components/viewsource/test/file_empty.html new file mode 100644 index 0000000000..495c23ec8a --- /dev/null +++ b/toolkit/components/viewsource/test/file_empty.html @@ -0,0 +1 @@ +<!DOCTYPE html><html><body></body></html> diff --git a/toolkit/components/viewsource/test/test_bug428653.html b/toolkit/components/viewsource/test/test_bug428653.html new file mode 100644 index 0000000000..f800cb8f5f --- /dev/null +++ b/toolkit/components/viewsource/test/test_bug428653.html @@ -0,0 +1,45 @@ +<!DOCTYPE HTML> +<html> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=428653 +--> +<head> + <title>View Source Test (bug 428653)</title> + <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/> +</head> +<body> + + <iframe id="content" src="http://example.org/tests/toolkit/components/viewsource/test/file_empty.html"></iframe> + + <script type="application/javascript"> + /* + Test that we can't call the content browser's document.open() over Xrays. + See the security checks in nsHTMLDocument::Open, which make sure that the + entry global's principal matches that of the document. + */ + SimpleTest.waitForExplicitFinish(); + + addLoadEvent(function testDocumentOpen() { + var browser = document.getElementById("content"); + ok(browser, "got browser"); + var doc = browser.contentDocument; + ok(doc, "got content document"); + + var opened = false; + try { + doc.open("text/html", "replace"); + opened = true; + } catch (e) { + is(e.name, "SecurityError", "Unexpected exception"); + } + is(opened, false, "Shouldn't have opened document"); + + doc.wrappedJSObject.open("text/html", "replace"); + ok(true, "Should be able to open document via Xray Waiver"); + + SimpleTest.finish(); + }); + </script> +</body> +</html> |