mozilla-central/dom/serviceworkers/test/browser_download_canceled.js (file symbol)

Source code

Revision control

Copy as Markdown

Other Tools

Test Info: Warnings

/* Any copyright is dedicated to the Public Domain.
/*
* Test cancellation of a download in order to test edge-cases related to
* channel diversion. Channel diversion occurs in cases of file (and PSM cert)
* downloads where we realize in the child that we really want to consume the
* channel data in the parent. For data "sourced" by the parent, like network
* data, data streaming to the child is suspended and the parent waits for the
* child to send back the data it already received, then the channel is resumed.
* For data generated by the child, such as (the current, to be mooted by
* parent-intercept) child-side intercept, the data (currently) stream is
* continually pumped up to the parent.
*
* In particular, we want to reproduce the circumstances of Bug 1418795 where
* the child-side input-stream pump attempts to send data to the parent process
* but the parent has canceled the channel and so the IPC Actor has been torn
* down. Diversion begins once the nsURILoader receives the OnStartRequest
* notification with the headers, so there are two ways to produce
*/
/**
* Clear the downloads list so other tests don't see our byproducts.
*/
async function clearDownloads() {
const downloads = await Downloads.getList(Downloads.ALL);
downloads.removeFinished();
}
/**
* Returns a Promise that will be resolved once the download dialog shows up and
* we have clicked the given button.
*/
function promiseClickDownloadDialogButton(buttonAction) {
return BrowserTestUtils.promiseAlertDialogOpen(buttonAction, uri, {
async callback(win) {
// nsHelperAppDlg.js currently uses an eval-based setTimeout(0) to invoke
// its postShowCallback that results in a misleading error to the console
// if we close the dialog before it gets a chance to run. Just a
// setTimeout is not sufficient because it appears we get our "load"
// listener before the document's, so we use TestUtils.waitForTick() to
// defer until after its load handler runs, then use setTimeout(0) to end
// up after its eval.
await TestUtils.waitForTick();
await new Promise(resolve => setTimeout(resolve, 0));
const button = win.document
.getElementById("unknownContentType")
.getButton(buttonAction);
button.disabled = false;
info(`clicking ${buttonAction} button`);
button.click();
},
});
}
async function performCanceledDownload(tab, path) {
// If we're going to show a modal dialog for this download, then we should
// use it to cancel the download. If not, then we have to let the download
// start and then call into the downloads API ourselves to cancel it.
// We use this promise to signal the cancel being complete in either case.
let cancelledDownload;
if (
Services.prefs.getBoolPref(
"browser.download.always_ask_before_handling_new_types",
false
)
) {
// Start waiting for the download dialog before triggering the download.
cancelledDownload = promiseClickDownloadDialogButton("cancel");
// Wait for the cancelation to have been triggered.
info("waiting for download popup");
} else {
let downloadView;
cancelledDownload = new Promise(resolve => {
downloadView = {
onDownloadAdded(aDownload) {
aDownload.cancel();
resolve();
},
};
});
const downloadList = await Downloads.getList(Downloads.ALL);
await downloadList.addView(downloadView);
}
// Trigger the download.
info(`triggering download of "${path}"`);
/* eslint-disable no-shadow */
await SpecialPowers.spawn(tab.linkedBrowser, [path], function (path) {
// Put a Promise in place that we can wait on for stream closure.
content.wrappedJSObject.trackStreamClosure(path);
// Create the link and trigger the download.
const link = content.document.createElement("a");
link.href = path;
link.download = path;
content.document.body.appendChild(link);
link.click();
});
/* eslint-enable no-shadow */
// Wait for the download to cancel.
await cancelledDownload;
info("cancelled download");
// Wait for confirmation that the stream stopped.
info(`wait for the ${path} stream to close.`);
/* eslint-disable no-shadow */
const why = await SpecialPowers.spawn(
tab.linkedBrowser,
[path],
function (path) {
return content.wrappedJSObject.streamClosed[path].promise;
}
);
/* eslint-enable no-shadow */
is(why.why, "canceled", "Ensure the stream canceled instead of timing out.");
// Note that for the "sw-stream-download" case, we end up with a bogus
// reason of "'close' may only be called on a stream in the 'readable' state."
// Since we aren't actually invoking close(), I'm assuming this is an
// implementation bug that will be corrected in the web platform tests.
info(`Cancellation reason: ${why.message} after ${why.ticks} ticks`);
}
const gTestRoot = getRootDirectory(gTestPath).replace(
);
const PAGE_URL = `${gTestRoot}download_canceled/page_download_canceled.html`;
add_task(async function interruptedDownloads() {
await SpecialPowers.pushPrefEnv({
set: [
["dom.serviceWorkers.enabled", true],
["dom.serviceWorkers.exemptFromPerDomainMax", true],
["dom.serviceWorkers.testing.enabled", true],
],
});
// Open the tab
const tab = await BrowserTestUtils.openNewForegroundTab({
gBrowser,
opening: PAGE_URL,
});
// Wait for it to become controlled. Check that it was a promise that
// resolved as expected rather than undefined by checking the return value.
const controlled = await SpecialPowers.spawn(
tab.linkedBrowser,
[],
function () {
// This is a promise set up by the page during load, and we are post-load.
return content.wrappedJSObject.controlled;
}
);
is(controlled, "controlled", "page became controlled");
// Download a pass-through fetch stream.
await performCanceledDownload(tab, "sw-passthrough-download");
// Download a SW-generated stream
await performCanceledDownload(tab, "sw-stream-download");
// Cleanup
await SpecialPowers.spawn(tab.linkedBrowser, [], function () {
return content.wrappedJSObject.registration.unregister();
});
BrowserTestUtils.removeTab(tab);
await clearDownloads();
});