tor-browser

browser_history_recently_closed.js (28101B)

---

/* 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/. */

"use strict";

const { SessionStoreTestUtils } = ChromeUtils.importESModule(
 "resource://testing-common/SessionStoreTestUtils.sys.mjs"
);
const { TabStateFlusher } = ChromeUtils.importESModule(
 "resource:///modules/sessionstore/TabStateFlusher.sys.mjs"
);
const triggeringPrincipal_base64 = E10SUtils.SERIALIZED_SYSTEMPRINCIPAL;

SessionStoreTestUtils.init(this, window);

const TEST_PATH = getRootDirectory(gTestPath).replace(
 "chrome://mochitests/content",
 "https://example.com"
);

let panelMenuWidgetAdded = false;
function prepareHistoryPanel() {
 if (panelMenuWidgetAdded) {
   return;
 }
 CustomizableUI.addWidgetToArea(
   "history-panelmenu",
   CustomizableUI.AREA_FIXED_OVERFLOW_PANEL
 );
 registerCleanupFunction(() => CustomizableUI.reset());
}

async function openRecentlyClosedTabsMenu(doc = window.document) {
 prepareHistoryPanel();
 await openHistoryPanel(doc);

 let recentlyClosedTabs = doc.getElementById("appMenuRecentlyClosedTabs");
 Assert.ok(
   !recentlyClosedTabs.getAttribute("disabled"),
   "Recently closed tabs button enabled"
 );
 let closeTabsPanel = doc.getElementById("appMenu-library-recentlyClosedTabs");
 let panelView = closeTabsPanel && PanelView.forNode(closeTabsPanel);
 if (!panelView?.active) {
   recentlyClosedTabs.click();
   closeTabsPanel = doc.getElementById("appMenu-library-recentlyClosedTabs");
   await BrowserTestUtils.waitForEvent(closeTabsPanel, "ViewShown");
   ok(
     PanelView.forNode(closeTabsPanel)?.active,
     "Opened 'Recently closed tabs' panel"
   );
 }

 return closeTabsPanel;
}

function makeTabState(url) {
 return {
   entries: [{ url, triggeringPrincipal_base64 }],
 };
}

function makeClosedTabState(url, { groupId, closedInTabGroup = false } = {}) {
 return {
   title: url,
   closedInTabGroupId: closedInTabGroup ? groupId : null,
   state: {
     entries: [
       {
         url,
         triggeringPrincipal_base64,
       },
     ],
     groupId,
   },
 };
}

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"
   );
 }
}

registerCleanupFunction(async () => {
 await resetClosedTabsAndWindows();
});

add_task(async function testRecentlyClosedDisabled() {
 info("Check history recently closed tabs/windows section");

 prepareHistoryPanel();
 // We need to make sure the history is cleared before starting the test
 await Sanitizer.sanitize(["history"]);

 await openHistoryPanel();

 let recentlyClosedTabs = document.getElementById("appMenuRecentlyClosedTabs");
 let recentlyClosedWindows = document.getElementById(
   "appMenuRecentlyClosedWindows"
 );

 // Wait for the disabled attribute to change, as we receive
 // the "viewshown" event before this changes
 await BrowserTestUtils.waitForCondition(
   () => recentlyClosedTabs.hasAttribute("disabled"),
   "Waiting for button to become disabled"
 );
 Assert.ok(
   recentlyClosedTabs.hasAttribute("disabled"),
   "Recently closed tabs button disabled"
 );
 Assert.ok(
   recentlyClosedWindows.hasAttribute("disabled"),
   "Recently closed windows button disabled"
 );

 await hideHistoryPanel();

 gBrowser.selectedTab.focus();
 await SessionStoreTestUtils.openAndCloseTab(
   window,
   TEST_PATH + "dummy_history_item.html"
 );

 await openHistoryPanel();

 await BrowserTestUtils.waitForCondition(
   () => !recentlyClosedTabs.hasAttribute("disabled"),
   "Waiting for button to be enabled"
 );
 Assert.ok(
   !recentlyClosedTabs.hasAttribute("disabled"),
   "Recently closed tabs is available"
 );
 Assert.ok(
   recentlyClosedWindows.hasAttribute("disabled"),
   "Recently closed windows button disabled"
 );

 await hideHistoryPanel();

 let newWin = await BrowserTestUtils.openNewBrowserWindow();
 let loadedPromise = BrowserTestUtils.browserLoaded(
   newWin.gBrowser.selectedBrowser
 );
 BrowserTestUtils.startLoadingURIString(
   newWin.gBrowser.selectedBrowser,
   "about:mozilla"
 );
 await loadedPromise;
 await BrowserTestUtils.closeWindow(newWin);

 await openHistoryPanel();

 await BrowserTestUtils.waitForCondition(
   () => !recentlyClosedWindows.hasAttribute("disabled"),
   "Waiting for button to be enabled"
 );
 Assert.ok(
   !recentlyClosedTabs.hasAttribute("disabled"),
   "Recently closed tabs is available"
 );
 Assert.ok(
   !recentlyClosedWindows.hasAttribute("disabled"),
   "Recently closed windows is available"
 );

 await hideHistoryPanel();
});

add_task(async function testRecentlyClosedTabsDisabledPersists() {
 info("Check history recently closed tabs/windows section");

 prepareHistoryPanel();

 // We need to make sure the history is cleared before starting the test
 await Sanitizer.sanitize(["history"]);

 await openHistoryPanel();

 let recentlyClosedTabs = document.getElementById("appMenuRecentlyClosedTabs");
 Assert.ok(
   recentlyClosedTabs.hasAttribute("disabled"),
   "Recently closed tabs button disabled"
 );

 await hideHistoryPanel();

 let newWin = await BrowserTestUtils.openNewBrowserWindow();

 await openHistoryPanel(newWin.document);
 recentlyClosedTabs = newWin.document.getElementById(
   "appMenuRecentlyClosedTabs"
 );
 Assert.ok(
   recentlyClosedTabs.hasAttribute("disabled"),
   "Recently closed tabs is disabled"
 );

 // We close the window without hiding the panel first, which used to interfere
 // with populating the view subsequently.
 await BrowserTestUtils.closeWindow(newWin);

 newWin = await BrowserTestUtils.openNewBrowserWindow();
 await openHistoryPanel(newWin.document);
 recentlyClosedTabs = newWin.document.getElementById(
   "appMenuRecentlyClosedTabs"
 );
 Assert.ok(
   recentlyClosedTabs.hasAttribute("disabled"),
   "Recently closed tabs is disabled"
 );
 await hideHistoryPanel(newWin.document);
 await BrowserTestUtils.closeWindow(newWin);
});

add_task(async function testRecentlyClosedRestoreAllTabs() {
 // We need to make sure the history is cleared before starting the test
 await Sanitizer.sanitize(["history"]);
 await resetClosedTabsAndWindows();
 const initialTabCount = gBrowser.visibleTabs.length;

 const closedTabUrls = [
   "about:robots",
   "https://example.com/",
   "https://example.org/",
 ];

 const closedTabGroupInOpenWindowUrls = ["about:logo", "about:logo"];
 const closedTabGroupInOpenWindowId = "1234567890-1";

 const closedTabGroupInClosedWindowUrls = ["about:robots", "about:robots"];
 const closedTabGroupInClosedWindowId = "1234567890-2";

 await SessionStoreTestUtils.promiseBrowserState({
   windows: [
     {
       tabs: [makeTabState("about:mozilla")],
       _closedTabs: closedTabUrls.map(makeClosedTabState),
       closedGroups: [
         {
           collapsed: false,
           color: "blue",
           id: closedTabGroupInOpenWindowId,
           name: "closed-in-open-window",
           tabs: closedTabGroupInOpenWindowUrls.map(url =>
             makeClosedTabState(url, { groupId: closedTabGroupInOpenWindowId })
           ),
         },
       ],
     },
   ],
   _closedWindows: [
     {
       tabs: [makeTabState("about:mozilla")],
       _closedTabs: [],
       closedGroups: [
         {
           collapsed: false,
           color: "red",
           id: closedTabGroupInClosedWindowId,
           name: "closed-in-closed-window",
           tabs: closedTabGroupInClosedWindowUrls.map(url =>
             makeClosedTabState(url, {
               groupId: closedTabGroupInClosedWindowId,
             })
           ),
         },
       ],
     },
   ],
 });

 is(gBrowser.visibleTabs.length, 1, "We start with one tab open");
 // Open the "Recently closed tabs" panel.
 let closeTabsPanel = await openRecentlyClosedTabsMenu();

 // Click the first toolbar button in the panel.
 let toolbarButton = closeTabsPanel.querySelector(
   ".panel-subview-body toolbarbutton"
 );
 let newTabPromise = BrowserTestUtils.waitForNewTab(gBrowser, null, true);
 EventUtils.sendMouseEvent({ type: "click" }, toolbarButton, window);

 info(
   "We should reopen the first of closedTabUrls: " +
     JSON.stringify(closedTabUrls)
 );
 let reopenedTab = await newTabPromise;
 is(
   reopenedTab.linkedBrowser.currentURI.spec,
   closedTabUrls[0],
   "Opened the first URL"
 );
 info(`restored tab, total open tabs: ${gBrowser.tabs.length}`);

 info("waiting for closeTab");
 await SessionStoreTestUtils.closeTab(reopenedTab);

 await openRecentlyClosedTabsMenu();
 let restoreAllItem = closeTabsPanel.querySelector(".restoreallitem");
 ok(
   restoreAllItem && !restoreAllItem.hidden,
   "Restore all menu item is not hidden"
 );

 // Click the restore-all toolbar button in the panel.
 EventUtils.sendMouseEvent({ type: "click" }, restoreAllItem, window);

 info("waiting for restored tabs");
 await BrowserTestUtils.waitForCondition(
   () => SessionStore.getClosedTabCount() === 0,
   "Waiting for all the closed tabs to be opened"
 );

 is(
   gBrowser.tabs.length,
   initialTabCount +
     closedTabUrls.length +
     closedTabGroupInOpenWindowUrls.length +
     closedTabGroupInClosedWindowUrls.length,
   "The expected number of closed tabs were restored"
 );
 is(
   gBrowser.tabGroups[0].id,
   closedTabGroupInOpenWindowId,
   "Closed tab group in open window was restored"
 );
 closedTabGroupInOpenWindowUrls.forEach((expectedUrl, index) => {
   is(
     gBrowser.tabGroups[0].tabs[index].linkedBrowser.currentURI.spec,
     expectedUrl,
     `Closed tab group in open window tab #${index} has correct URL`
   );
 });
 is(
   gBrowser.tabGroups[1].id,
   closedTabGroupInClosedWindowId,
   "Closed tab group in closed window was restored"
 );
 closedTabGroupInClosedWindowUrls.forEach((expectedUrl, index) => {
   is(
     gBrowser.tabGroups[1].tabs[index].linkedBrowser.currentURI.spec,
     expectedUrl,
     `Closed tab group in closed window tab #${index} has correct URL`
   );
 });

 // clean up extra tabs
 while (gBrowser.tabs.length > 1) {
   BrowserTestUtils.removeTab(gBrowser.tabs.at(-1));
 }
});

add_task(async function testRecentlyClosedWindows() {
 // We need to make sure the history is cleared before starting the test
 await Sanitizer.sanitize(["history"]);
 await resetClosedTabsAndWindows();

 // Open and close a new window.
 let newWin = await BrowserTestUtils.openNewBrowserWindow();
 let loadedPromise = BrowserTestUtils.browserLoaded(
   newWin.gBrowser.selectedBrowser
 );
 BrowserTestUtils.startLoadingURIString(
   newWin.gBrowser.selectedBrowser,
   "https://example.com"
 );
 await loadedPromise;
 let closedObjectsChangePromise = TestUtils.topicObserved(
   "sessionstore-closed-objects-changed"
 );
 await BrowserTestUtils.closeWindow(newWin);
 await closedObjectsChangePromise;

 prepareHistoryPanel();
 await openHistoryPanel();

 // Open the "Recently closed windows" panel.
 document.getElementById("appMenuRecentlyClosedWindows").click();

 let winPanel = document.getElementById(
   "appMenu-library-recentlyClosedWindows"
 );
 await BrowserTestUtils.waitForEvent(winPanel, "ViewShown");
 ok(true, "Opened 'Recently closed windows' panel");

 // Click the first toolbar button in the panel.
 let panelBody = winPanel.querySelector(".panel-subview-body");
 let toolbarButton = panelBody.querySelector("toolbarbutton");
 let newWindowPromise = BrowserTestUtils.waitForNewWindow({
   url: "https://example.com/",
 });
 closedObjectsChangePromise = TestUtils.topicObserved(
   "sessionstore-closed-objects-changed"
 );
 EventUtils.sendMouseEvent({ type: "click" }, toolbarButton, window);

 newWin = await newWindowPromise;
 await closedObjectsChangePromise;
 is(gBrowser.tabs.length, 1, "Did not open new tabs");

 await BrowserTestUtils.closeWindow(newWin);
});

add_task(async function testRecentlyClosedTabsFromClosedWindows() {
 await resetClosedTabsAndWindows();
 const closedTabUrls = [
   "about:robots",
   "https://example.com/",
   "https://example.org/",
 ];
 const closedWindowState = {
   tabs: [
     {
       entries: [{ url: "about:mozilla", triggeringPrincipal_base64 }],
     },
   ],
   closedGroups: [],
   _closedTabs: closedTabUrls.map(url => {
     return {
       title: url,
       state: {
         entries: [
           {
             url,
             triggeringPrincipal_base64,
           },
         ],
       },
     };
   }),
 };
 await SessionStoreTestUtils.promiseBrowserState({
   windows: [
     {
       tabs: [
         {
           entries: [{ url: "about:mozilla", triggeringPrincipal_base64 }],
         },
       ],
     },
   ],
   _closedWindows: [closedWindowState],
 });
 Assert.equal(
   SessionStore.getClosedTabCountFromClosedWindows(),
   closedTabUrls.length,
   "Sanity check number of closed tabs from closed windows"
 );

 prepareHistoryPanel();
 let closeTabsPanel = await openRecentlyClosedTabsMenu();
 // make sure we can actually restore one of these closed tabs
 const closedTabItems = closeTabsPanel.querySelectorAll(
   "toolbarbutton[targetURI]"
 );
 Assert.equal(
   closedTabItems.length,
   closedTabUrls.length,
   "We have expected number of closed tab items"
 );

 const newTabPromise = BrowserTestUtils.waitForNewTab(gBrowser, null, true);
 const closedObjectsChangePromise = TestUtils.topicObserved(
   "sessionstore-closed-objects-changed"
 );
 EventUtils.sendMouseEvent({ type: "click" }, closedTabItems[0], window);
 await newTabPromise;
 await closedObjectsChangePromise;

 // flip the pref so none of the closed tabs from closed window are included
 await SpecialPowers.pushPrefEnv({
   set: [["browser.sessionstore.closedTabsFromClosedWindows", false]],
 });
 await openHistoryPanel();

 // verify the recently-closed-tabs menu item is disabled
 let recentlyClosedTabsItem = document.getElementById(
   "appMenuRecentlyClosedTabs"
 );
 Assert.ok(
   recentlyClosedTabsItem.hasAttribute("disabled"),
   "Recently closed tabs button is now disabled"
 );
 await hideHistoryPanel();

 SpecialPowers.popPrefEnv();
 while (gBrowser.tabs.length > 1) {
   await SessionStoreTestUtils.closeTab(
     gBrowser.tabs[gBrowser.tabs.length - 1]
   );
 }
});

add_task(async function testRecentlyClosedTabGroupsSingleTab() {
 // We need to make sure the history is cleared before starting the test
 await Sanitizer.sanitize(["history"]);
 await resetClosedTabsAndWindows();
 prepareHistoryPanel();

 is(gBrowser.visibleTabs.length, 1, "We start with one tab already open");

 let aboutMozillaTab = BrowserTestUtils.addTab(gBrowser, "about:mozilla");
 let aboutLogoTab = BrowserTestUtils.addTab(gBrowser, "about:logo");
 let mozillaTabGroup = gBrowser.addTabGroup([aboutMozillaTab, aboutLogoTab], {
   color: "red",
   label: "mozilla stuff",
 });
 const mozillaTabGroupId = mozillaTabGroup.id;
 const mozillaTabGroupName = mozillaTabGroup.label;
 let aboutRobotsTab = BrowserTestUtils.addTab(gBrowser, "about:robots");

 info("load all of the tabs");
 await Promise.all(
   [aboutMozillaTab, aboutLogoTab, aboutRobotsTab].map(async t => {
     await BrowserTestUtils.browserLoaded(t.linkedBrowser);
     await TabStateFlusher.flush(t.linkedBrowser);
   })
 );

 info("close the tab group and wait for it to be removed");
 let removePromise = BrowserTestUtils.waitForEvent(
   mozillaTabGroup,
   "TabGroupRemoved"
 );
 gBrowser.removeTabGroup(mozillaTabGroup);
 await removePromise;

 is(
   gBrowser.visibleTabs.length,
   2,
   "The tab from before the test plus about:robots should still be open"
 );
 info("Open the 'Recently closed tabs' panel.");
 let closeTabsPanel = await openRecentlyClosedTabsMenu();

 // Click the tab group button in the panel.
 let tabGroupToolbarButton = closeTabsPanel.querySelector(
   `.panel-subview-body toolbarbutton[label="${mozillaTabGroupName}"]`
 );
 ok(tabGroupToolbarButton, "should find the tab group toolbar button");

 let tabGroupPanelview = document.getElementById(
   `closed-tabs-tab-group-${mozillaTabGroupId}`
 );
 ok(tabGroupPanelview, "should find the tab group panelview");

 EventUtils.sendMouseEvent({ type: "click" }, tabGroupToolbarButton, window);
 await BrowserTestUtils.waitForEvent(tabGroupPanelview, "ViewShown");

 info("restore the first tab from the closed tab group");
 let newTabPromise = BrowserTestUtils.waitForNewTab(gBrowser, null, true);
 let tabToolbarButton = tabGroupPanelview.querySelector(
   ".panel-subview-body toolbarbutton"
 );
 ok(tabToolbarButton, "should find at least one tab to restore");
 let tabTitle = tabToolbarButton.label;
 EventUtils.sendMouseEvent({ type: "click" }, tabToolbarButton, window);

 let reopenedTab = await newTabPromise;
 is(reopenedTab.label, tabTitle, "Opened the first URL");
 info(`restored tab, total open tabs: ${gBrowser.tabs.length}`);

 // clean up extra tabs
 while (gBrowser.tabs.length > 1) {
   BrowserTestUtils.removeTab(gBrowser.tabs.at(-1));
 }
});

add_task(async function testRecentlyClosedTabGroupOpensFromAnyWindow() {
 // We need to make sure the history is cleared before starting the test
 await Sanitizer.sanitize(["history"]);
 await resetClosedTabsAndWindows();
 prepareHistoryPanel();

 is(gBrowser.visibleTabs.length, 1, "We start with one tab already open");

 let groupedTab = BrowserTestUtils.addTab(gBrowser, "https://example.com");
 await BrowserTestUtils.browserLoaded(groupedTab.linkedBrowser);
 await TabStateFlusher.flush(groupedTab.linkedBrowser);
 let tabGroup = gBrowser.addTabGroup([groupedTab], { label: "Some group" });
 const tabGroupId = tabGroup.id;
 const tabGroupLabel = tabGroup.label;

 info("close the tab group and wait for it to be removed");
 let removePromise = BrowserTestUtils.waitForEvent(
   tabGroup,
   "TabGroupRemoved"
 );
 gBrowser.removeTabGroup(tabGroup);
 await removePromise;

 let newWin = await BrowserTestUtils.openNewBrowserWindow();
 let closeTabsPanel = await openRecentlyClosedTabsMenu(newWin.document);

 // Click the tab group button in the panel.
 let tabGroupToolbarButton = closeTabsPanel.querySelector(
   `.panel-subview-body toolbarbutton[label="${tabGroupLabel}"]`
 );
 ok(tabGroupToolbarButton, "should find the tab group toolbar button");

 let tabGroupPanelview = newWin.document.getElementById(
   `closed-tabs-tab-group-${tabGroupId}`
 );
 ok(tabGroupPanelview, "should find the tab group panelview");

 EventUtils.sendMouseEvent({ type: "click" }, tabGroupToolbarButton, window);
 await BrowserTestUtils.waitForEvent(tabGroupPanelview, "ViewShown");

 let tabToolbarButton = tabGroupPanelview.querySelector(
   "toolbarbutton.reopentabgroupitem"
 );
 let tabGroupRestored = BrowserTestUtils.waitForEvent(
   newWin.gBrowser.tabContainer,
   "SSTabRestored"
 );
 EventUtils.sendMouseEvent({ type: "click" }, tabToolbarButton, window);
 await tabGroupRestored;

 is(
   newWin.gBrowser.tabGroups.length,
   1,
   "Tab group added to new window tab strip"
 );
 is(
   newWin.gBrowser.tabGroups[0].label,
   tabGroupLabel,
   "Tab group label is the same as it was before restore"
 );

 await BrowserTestUtils.closeWindow(newWin);
});

add_task(async function testRecentlyClosedTabsFromManyWindows() {
 // Ensures that bug1943850 has a proper resolution.
 info(
   "Tabs must be indexed by individual window, even when multiple windows are open"
 );

 await resetClosedTabsAndWindows();
 const ORIG_STATE = SessionStore.getBrowserState();

 await SessionStoreTestUtils.promiseBrowserState({
   windows: [
     {
       tabs: [makeTabState("about:mozilla")],
       _closedTabs: [
         makeClosedTabState("about:mozilla"),
         makeClosedTabState("about:mozilla"),
       ],
     },
     {
       tabs: [makeTabState("about:mozilla")],
       _closedTabs: [makeClosedTabState("about:robots")],
     },
   ],
 });

 Assert.equal(
   SessionStore.getClosedTabCount(),
   3,
   "Sanity check number of closed tabs from closed windows"
 );

 prepareHistoryPanel();
 let closeTabsPanel = await openRecentlyClosedTabsMenu();

 info("make sure we can actually restore one of these closed tabs");
 const closedTabItems = closeTabsPanel.querySelectorAll(
   "toolbarbutton[targetURI]"
 );
 Assert.equal(
   closedTabItems.length,
   3,
   "We have expected number of closed tab items"
 );

 const newTabPromise = BrowserTestUtils.waitForNewTab(gBrowser, null, true);
 const closedObjectsChangePromise = TestUtils.topicObserved(
   "sessionstore-closed-objects-changed"
 );
 EventUtils.sendMouseEvent({ type: "click" }, closedTabItems[2], window);
 await newTabPromise;
 await closedObjectsChangePromise;

 Assert.equal(
   gBrowser.tabs[1].linkedBrowser.currentURI.spec,
   "about:robots",
   "Closed tab from the second window is opened"
 );

 await SessionStoreTestUtils.promiseBrowserState(ORIG_STATE);
});

add_task(async function testTabsFromGroupClosedBeforeGroupDeleted() {
 // Ensures that bug1945111 has a proper resolution.
 info(
   "Tabs that were closed from within a tab group should appear in history menus as standalone tabs, even if the tab group is later deleted"
 );

 await resetClosedTabsAndWindows();
 const ORIG_STATE = SessionStore.getBrowserState();
 const GROUP_ID = "1234567890-1";

 await SessionStoreTestUtils.promiseBrowserState({
   windows: [
     {
       tabs: [makeTabState("about:blank")],
       _closedTabs: [
         makeClosedTabState("about:mozilla", { groupId: GROUP_ID }),
       ],
       closedGroups: [
         {
           id: GROUP_ID,
           color: "blue",
           name: "tab-group",
           tabs: [
             makeClosedTabState("about:mozilla", {
               groupId: GROUP_ID,
               closedInTabGroup: true,
             }),
             makeClosedTabState("about:mozilla", {
               groupId: GROUP_ID,
               closedInTabGroup: true,
             }),
             makeClosedTabState("about:mozilla", {
               groupId: GROUP_ID,
               closedInTabGroup: true,
             }),
           ],
         },
       ],
     },
   ],
 });

 Assert.equal(
   SessionStore.getClosedTabCount(),
   4,
   "Sanity check number of closed tabs from closed windows"
 );

 let closeTabsPanel = await openRecentlyClosedTabsMenu();

 const topLevelClosedTabItems = closeTabsPanel
   .querySelector(".panel-subview-body")
   .querySelectorAll(":scope > toolbarbutton[targetURI]");
 Assert.equal(
   topLevelClosedTabItems.length,
   1,
   "We have the expected number of top-level closed tab items"
 );

 const tabGroupClosedTabItems = closeTabsPanel.querySelectorAll(
   `panelview#closed-tabs-tab-group-${GROUP_ID} toolbarbutton[targetURI]`
 );
 Assert.equal(
   tabGroupClosedTabItems.length,
   3,
   "We have the expected number of closed tab items within the tab group"
 );

 await hideHistoryPanel();

 await SessionStoreTestUtils.promiseBrowserState(ORIG_STATE);
});

add_task(async function testOpenTabFromClosedGroupInClosedWindow() {
 // Asserts fix for bug1944416
 info(
   "Open a tab from a closed tab group in a closed window as a standalone tab"
 );
 await Sanitizer.sanitize(["history"]);
 await resetClosedTabsAndWindows();
 const ORIG_STATE = SessionStore.getBrowserState();

 const closedTabUrl = "about:robots";
 const closedTabGroupUrls = ["about:logo", "https://example.com"];
 const closedTabGroupId = "1234567890-1";

 await SessionStoreTestUtils.promiseBrowserState({
   windows: [
     {
       tabs: [makeTabState("about:blank")],
       _closedTabs: [],
       closedGroups: [],
     },
   ],
   _closedWindows: [
     {
       tabs: [makeTabState("about:blank")],
       _closedTabs: [makeClosedTabState(closedTabUrl)],
       closedGroups: [
         {
           id: closedTabGroupId,
           color: "red",
           name: "tab-group",
           tabs: closedTabGroupUrls.map(url =>
             makeClosedTabState(url, {
               groupId: closedTabGroupId,
               closedInTabGroup: true,
             })
           ),
         },
       ],
     },
   ],
 });

 Assert.equal(
   SessionStore.getClosedTabCountFromClosedWindows(),
   closedTabGroupUrls.length + 1, // Add the lone ungrouped closed tab
   "Sanity check number of closed tabs from closed windows"
 );

 let closeTabsPanel = await openRecentlyClosedTabsMenu();
 const closedTabItems = closeTabsPanel.querySelectorAll(
   "toolbarbutton[targetURI]"
 );

 let newTabPromise = BrowserTestUtils.waitForNewTab(gBrowser, null, true);
 let closedObjectsChangePromise = TestUtils.topicObserved(
   "sessionstore-closed-objects-changed"
 );
 EventUtils.sendMouseEvent({ type: "click" }, closedTabItems[0], window);
 await newTabPromise;
 await closedObjectsChangePromise;

 Assert.equal(
   gBrowser.tabs.at(-1).linkedBrowser.currentURI.spec,
   closedTabUrl,
   "Ungrouped closed tab from closed window is opened correctly in the presence of closed tab groups"
 );

 closeTabsPanel = await openRecentlyClosedTabsMenu();
 const tabGroupClosedTabItems = closeTabsPanel.querySelectorAll(
   `panelview#closed-tabs-tab-group-${closedTabGroupId} toolbarbutton[targetURI]`
 );

 newTabPromise = BrowserTestUtils.waitForNewTab(gBrowser, null, true);
 closedObjectsChangePromise = TestUtils.topicObserved(
   "sessionstore-closed-objects-changed"
 );
 EventUtils.sendMouseEvent(
   { type: "click" },
   tabGroupClosedTabItems[0],
   window
 );
 await newTabPromise;
 await closedObjectsChangePromise;

 Assert.equal(
   gBrowser.tabs.at(-1).linkedBrowser.currentURI.spec,
   closedTabGroupUrls[0],
   "Grouped closed tab from closed window is opened correctly"
 );

 await SessionStoreTestUtils.promiseBrowserState(ORIG_STATE);
});

add_task(async function testHistoryMenusWorkWithOldPreTabGroupsState() {
 info(
   "Ensure that a session file created before the release of tab groups does not prevent closed tabs in closed windows from opening"
 );
 // Fixes bug1947503

 // We need to make sure the history is cleared before starting the test
 await Sanitizer.sanitize(["history"]);
 await resetClosedTabsAndWindows();
 const ORIG_STATE = SessionStore.getBrowserState();

 const closedTabUrls = [
   "about:robots",
   "https://example.com/",
   "https://example.org/",
 ];

 await SessionStoreTestUtils.promiseBrowserState({
   windows: [
     {
       tabs: [makeTabState("about:mozilla")],
       _closedTabs: [],
       // No closedGroups element
     },
   ],
   _closedWindows: [
     {
       tabs: [makeTabState("about:mozilla")],
       _closedTabs: closedTabUrls.map(makeClosedTabState),
       // No closedGroups element
     },
   ],
 });

 is(gBrowser.visibleTabs.length, 1, "We start with one tab open");
 // Open the "Recently closed tabs" panel.
 let closeTabsPanel = await openRecentlyClosedTabsMenu();

 // Click the first toolbar button in the panel.
 let toolbarButton = closeTabsPanel.querySelector(
   ".panel-subview-body toolbarbutton"
 );
 let newTabPromise = BrowserTestUtils.waitForNewTab(gBrowser, null, true);
 EventUtils.sendMouseEvent({ type: "click" }, toolbarButton, window);
 let reopenedTab = await newTabPromise;

 is(gBrowser.tabs.length, 2, "Closed tab was restored");

 await SessionStoreTestUtils.closeTab(reopenedTab);
 await SessionStoreTestUtils.promiseBrowserState(ORIG_STATE);
});