From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 02:47:55 +0200 Subject: Adding upstream version 124.0.1. Signed-off-by: Daniel Baumann --- .../browser_history_recently_closed_tabs.js | 397 +++++++++++++++++++++ 1 file changed, 397 insertions(+) create mode 100644 browser/base/content/test/menubar/browser_history_recently_closed_tabs.js (limited to 'browser/base/content/test/menubar/browser_history_recently_closed_tabs.js') diff --git a/browser/base/content/test/menubar/browser_history_recently_closed_tabs.js b/browser/base/content/test/menubar/browser_history_recently_closed_tabs.js new file mode 100644 index 0000000000..246dce4db0 --- /dev/null +++ b/browser/base/content/test/menubar/browser_history_recently_closed_tabs.js @@ -0,0 +1,397 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ +/** + * This test verifies behavior from bug 1819675: + * https://bugzilla.mozilla.org/show_bug.cgi?id=1819675 + * + * The recently closed tabs menu item should be enabled when there are tabs + * closed from any window that is in the same private/non-private bucket as + * the current window. + */ + +const { SessionStoreTestUtils } = ChromeUtils.importESModule( + "resource://testing-common/SessionStoreTestUtils.sys.mjs" +); +const triggeringPrincipal_base64 = E10SUtils.SERIALIZED_SYSTEMPRINCIPAL; +SessionStoreTestUtils.init(this, window); + +async function checkMenu(window, expected) { + await SimpleTest.promiseFocus(window); + const historyMenubarItem = window.document.getElementById("history-menu"); + const historyMenu = window.document.getElementById("historyMenuPopup"); + const recentlyClosedTabsItem = historyMenu.querySelector("#historyUndoMenu"); + + const menuShown = BrowserTestUtils.waitForEvent(historyMenu, "popupshown"); + historyMenubarItem.openMenu(true); + info("checkMenu:, waiting for menuShown"); + await menuShown; + + Assert.equal( + recentlyClosedTabsItem.disabled, + expected.menuItemDisabled, + `Recently closed tabs menu item is ${ + expected.menuItemDisabled ? "disabled" : "not disabled" + }` + ); + const menuHidden = BrowserTestUtils.waitForEvent(historyMenu, "popuphidden"); + historyMenu.hidePopup(); + info("checkMenu:, waiting for menuHidden"); + await menuHidden; + info("checkMenu:, menuHidden, returning"); +} + +function resetClosedTabsAndWindows() { + // Clear the lists of closed windows and tabs. + Services.obs.notifyObservers(null, "browser:purge-session-history"); + is(SessionStore.getClosedWindowCount(), 0, "Expect 0 closed windows"); + for (const win of BrowserWindowTracker.orderedWindows) { + is( + SessionStore.getClosedTabCountForWindow(win), + 0, + "Expect 0 closed tabs for this window" + ); + } +} + +add_task(async function test_recently_closed_tabs_nonprivate() { + await resetClosedTabsAndWindows(); + + const win1 = window; + const win2 = await BrowserTestUtils.openNewBrowserWindow(); + await BrowserTestUtils.openNewForegroundTab( + win1.gBrowser, + "https://example.com" + ); + // we're going to close a tab and don't want to accidentally close the window when it has 0 tabs + await BrowserTestUtils.openNewForegroundTab(win2.gBrowser, "about:about"); + await BrowserTestUtils.openNewForegroundTab( + win2.gBrowser, + "https://example.org" + ); + + info("Checking the menuitem is initially disabled in both windows"); + for (let win of [win1, win2]) { + await checkMenu(win, { + menuItemDisabled: true, + }); + } + + await SessionStoreTestUtils.closeTab(win2.gBrowser.selectedTab); + is( + SessionStore.getClosedTabCount(), + 1, + "Expect closed tab count of 1 after closing a tab" + ); + + for (let win of [win1, win2]) { + await checkMenu(win, { + menuItemDisabled: false, + }); + } + + // clean up + info("clean up opened window"); + const sessionStoreChanged = TestUtils.topicObserved( + "sessionstore-closed-objects-changed" + ); + await BrowserTestUtils.closeWindow(win2); + await sessionStoreChanged; + + info("starting tab cleanup"); + while (gBrowser.tabs.length > 1) { + await SessionStoreTestUtils.closeTab( + gBrowser.tabs[gBrowser.tabs.length - 1] + ); + } + info("finished tab cleanup"); +}); + +add_task(async function test_recently_closed_tabs_nonprivate_pref_off() { + await SpecialPowers.pushPrefEnv({ + set: [["browser.sessionstore.closedTabsFromAllWindows", false]], + }); + await resetClosedTabsAndWindows(); + + const win1 = window; + const win2 = await BrowserTestUtils.openNewBrowserWindow(); + await BrowserTestUtils.openNewForegroundTab( + win1.gBrowser, + "https://example.com" + ); + // we're going to close a tab and don't want to accidentally close the window when it has 0 tabs + await BrowserTestUtils.openNewForegroundTab(win2.gBrowser, "about:about"); + await BrowserTestUtils.openNewForegroundTab( + win2.gBrowser, + "https://example.org" + ); + + info("Checking the menuitem is initially disabled in both windows"); + for (let win of [win1, win2]) { + await checkMenu(win, { + menuItemDisabled: true, + }); + } + await SimpleTest.promiseFocus(win2); + await SessionStoreTestUtils.closeTab(win2.gBrowser.selectedTab); + is( + SessionStore.getClosedTabCount(), + 1, + "Expect closed tab count of 1 after closing a tab" + ); + + await checkMenu(win1, { + menuItemDisabled: true, + }); + await checkMenu(win2, { + menuItemDisabled: false, + }); + + // clean up + info("clean up opened window"); + const sessionStoreChanged = TestUtils.topicObserved( + "sessionstore-closed-objects-changed" + ); + await BrowserTestUtils.closeWindow(win2); + await sessionStoreChanged; + + info("starting tab cleanup"); + while (gBrowser.tabs.length > 1) { + await SessionStoreTestUtils.closeTab( + gBrowser.tabs[gBrowser.tabs.length - 1] + ); + } + info("finished tab cleanup"); + SpecialPowers.popPrefEnv(); +}); + +add_task(async function test_recently_closed_tabs_mixed_private() { + await resetClosedTabsAndWindows(); + is( + SessionStore.getClosedTabCount(), + 0, + "Expect closed tab count of 0 after reset" + ); + + await BrowserTestUtils.openNewForegroundTab(window.gBrowser, "about:robots"); + await BrowserTestUtils.openNewForegroundTab( + window.gBrowser, + "https://example.com" + ); + + const privateWin = await BrowserTestUtils.openNewBrowserWindow({ + private: true, + }); + await BrowserTestUtils.openNewForegroundTab( + privateWin.gBrowser, + "about:about" + ); + await BrowserTestUtils.openNewForegroundTab( + privateWin.gBrowser, + "https://example.org" + ); + + for (let win of [window, privateWin]) { + await checkMenu(win, { + menuItemDisabled: true, + }); + } + + await SessionStoreTestUtils.closeTab(privateWin.gBrowser.selectedTab); + is( + SessionStore.getClosedTabCount(privateWin), + 1, + "Expect closed tab count of 1 for private windows" + ); + is( + SessionStore.getClosedTabCount(window), + 0, + "Expect closed tab count of 0 for non-private windows" + ); + + // the menu should be enabled only for the private window + await checkMenu(window, { + menuItemDisabled: true, + }); + await checkMenu(privateWin, { + menuItemDisabled: false, + }); + + await resetClosedTabsAndWindows(); + await SimpleTest.promiseFocus(window); + + info("closing tab in non-private window"); + await SessionStoreTestUtils.closeTab(window.gBrowser.selectedTab); + is( + SessionStore.getClosedTabCount(window), + 1, + "Expect 1 closed tab count after closing the a tab in the non-private window" + ); + + // the menu should be enabled only for the non-private window + await checkMenu(window, { + menuItemDisabled: false, + }); + await checkMenu(privateWin, { + menuItemDisabled: true, + }); + + // clean up + info("closing private window"); + await BrowserTestUtils.closeWindow(privateWin); + await TestUtils.waitForTick(); + + info("starting tab cleanup"); + while (gBrowser.tabs.length > 1) { + await SessionStoreTestUtils.closeTab( + gBrowser.tabs[gBrowser.tabs.length - 1] + ); + } + info("finished tab cleanup"); +}); + +add_task(async function test_recently_closed_tabs_mixed_private_pref_off() { + await SpecialPowers.pushPrefEnv({ + set: [["browser.sessionstore.closedTabsFromAllWindows", false]], + }); + await resetClosedTabsAndWindows(); + + await BrowserTestUtils.openNewForegroundTab(window.gBrowser, "about:robots"); + await BrowserTestUtils.openNewForegroundTab( + window.gBrowser, + "https://example.com" + ); + + const privateWin = await BrowserTestUtils.openNewBrowserWindow({ + private: true, + }); + await BrowserTestUtils.openNewForegroundTab( + privateWin.gBrowser, + "about:about" + ); + await BrowserTestUtils.openNewForegroundTab( + privateWin.gBrowser, + "https://example.org" + ); + + for (let win of [window, privateWin]) { + await checkMenu(win, { + menuItemDisabled: true, + }); + } + + await SimpleTest.promiseFocus(privateWin); + await SessionStoreTestUtils.closeTab(privateWin.gBrowser.selectedTab); + is( + SessionStore.getClosedTabCount(privateWin), + 1, + "Expect closed tab count of 1 for private windows" + ); + is( + SessionStore.getClosedTabCount(window), + 0, + "Expect closed tab count of 0 for non-private windows" + ); + + // the menu should be enabled only for the private window + await checkMenu(window, { + menuItemDisabled: true, + }); + await checkMenu(privateWin, { + menuItemDisabled: false, + }); + + await resetClosedTabsAndWindows(); + is( + SessionStore.getClosedTabCount(privateWin), + 0, + "Expect 0 closed tab count after reset" + ); + is( + SessionStore.getClosedTabCount(window), + 0, + "Expect 0 closed tab count after reset" + ); + + info("closing tab in non-private window"); + await SimpleTest.promiseFocus(window); + await SessionStoreTestUtils.closeTab(window.gBrowser.selectedTab); + + // the menu should be enabled only for the non-private window + await checkMenu(window, { + menuItemDisabled: false, + }); + await checkMenu(privateWin, { + menuItemDisabled: true, + }); + + // clean up + info("closing private window"); + await BrowserTestUtils.closeWindow(privateWin); + await TestUtils.waitForTick(); + + info("starting tab cleanup"); + while (gBrowser.tabs.length > 1) { + await SessionStoreTestUtils.closeTab( + gBrowser.tabs[gBrowser.tabs.length - 1] + ); + } + info("finished tab cleanup"); + SpecialPowers.popPrefEnv(); +}); + +add_task(async function test_recently_closed_tabs_closed_windows() { + // prepare window state with closed tabs from closed windows + await SpecialPowers.pushPrefEnv({ + set: [["sessionstore.closedTabsFromClosedWindows", true]], + }); + const closedTabUrls = ["about:robots"]; + const closedWindowState = { + tabs: [ + { + entries: [{ url: "about:mozilla", triggeringPrincipal_base64 }], + }, + ], + _closedTabs: closedTabUrls.map(url => { + return { + state: { + entries: [ + { + url, + triggeringPrincipal_base64, + }, + ], + }, + }; + }), + }; + await SessionStoreTestUtils.promiseBrowserState({ + windows: [ + { + tabs: [ + { + entries: [{ url: "about:mozilla", triggeringPrincipal_base64 }], + }, + ], + }, + ], + _closedWindows: [closedWindowState], + }); + + // verify the recently-closed-tabs menu item is enabled + await checkMenu(window, { + menuItemDisabled: false, + }); + + // flip the pref + await SpecialPowers.popPrefEnv(); + await SpecialPowers.pushPrefEnv({ + set: [["browser.sessionstore.closedTabsFromClosedWindows", false]], + }); + + // verify the recently-closed-tabs menu item is disabled + await checkMenu(window, { + menuItemDisabled: true, + }); + + SpecialPowers.popPrefEnv(); +}); -- cgit v1.2.3