tor-browser

browser_NavigableManager.js (16746B)

---

/* Any copyright is dedicated to the Public Domain.
* http://creativecommons.org/publicdomain/zero/1.0/ */

"use strict";

const { NavigableManager } = ChromeUtils.importESModule(
 "chrome://remote/content/shared/NavigableManager.sys.mjs"
);

const BUILDER_URL = "https://example.com/document-builder.sjs?html=";
const FRAME_URL = "https://example.com/document-builder.sjs?html=frame";
const FRAME_MARKUP = `
 <iframe src="${encodeURI(FRAME_URL)}"></iframe>
 <iframe src="${encodeURI(FRAME_URL)}"></iframe>
`;
const TEST_URL = BUILDER_URL + encodeURI(FRAME_MARKUP);

describe("NavigableManager", function () {
 let testData;

 beforeEach(async () => {
   NavigableManager.startTracking();

   const initialBrowser = gBrowser.selectedBrowser;
   const initialContext = initialBrowser.browsingContext;

   info(`Open a new tab and navigate to ${TEST_URL}`);
   const newTab = await addTabAndWaitForNavigated(gBrowser, TEST_URL);

   const newBrowser = newTab.linkedBrowser;
   const newContext = newBrowser.browsingContext;
   const newFrameContexts = newContext
     .getAllBrowsingContextsInSubtree()
     .filter(context => context.parent);

   is(newFrameContexts.length, 2, "Top context has 2 child contexts");

   testData = {
     initialBrowser,
     initialContext,
     newBrowser,
     newContext,
     newFrameContexts,
     newTab,
   };
 });

 afterEach(() => {
   NavigableManager.stopTracking();

   gBrowser.removeAllTabsBut(gBrowser.tabs[0]);
 });

 it("Get the browser by its Navigable id", async function test_getBrowserById() {
   const { initialBrowser, newBrowser } = testData;

   const invalidValues = [undefined, null, 1, "foo", {}, []];
   invalidValues.forEach(value =>
     is(NavigableManager.getBrowserById(value), null)
   );

   const initialBrowserId = NavigableManager.getIdForBrowser(initialBrowser);
   const newBrowserId = NavigableManager.getIdForBrowser(newBrowser);

   Assert.stringMatches(
     initialBrowserId,
     uuidRegex,
     "Initial browser is a valid uuid"
   );
   Assert.stringMatches(
     newBrowserId,
     uuidRegex,
     "New tab's browser is a valid uuid"
   );
   isnot(initialBrowserId, newBrowserId, "Both browsers have different ids");

   is(NavigableManager.getBrowserById(initialBrowserId), initialBrowser);
   is(NavigableManager.getBrowserById(newBrowserId), newBrowser);
 });

 it("Get the BrowsingContext by its Navigable id", async function test_getBrowsingContextById() {
   const { newContext, newFrameContexts } = testData;

   const invalidValues = [undefined, null, "foo", {}, []];
   invalidValues.forEach(value =>
     is(NavigableManager.getBrowsingContextById(value), null)
   );

   const newContextId = NavigableManager.getIdForBrowsingContext(newContext);
   const newFrameContextIds = newFrameContexts.map(context =>
     NavigableManager.getIdForBrowsingContext(context)
   );

   Assert.stringMatches(
     newContextId,
     uuidRegex,
     "Top context is a valid uuid"
   );
   Assert.stringMatches(
     newFrameContextIds[0],
     numberRegex,
     "First child context has a valid id"
   );
   Assert.stringMatches(
     newFrameContextIds[1],
     numberRegex,
     "Second child context has a valid id"
   );
   isnot(
     newContextId,
     newFrameContextIds[0],
     "Id of top-level context is different from first child context"
   );
   isnot(
     newContextId,
     newFrameContextIds[0],
     "Id of top-level context is different from second child context"
   );
   is(
     NavigableManager.getBrowsingContextById(newFrameContextIds[0]),
     newFrameContexts[0],
     "Context of first child can be retrieved by id"
   );
   is(
     NavigableManager.getBrowsingContextById(newFrameContextIds[1]),
     newFrameContexts[1],
     "Context of second child can be retrieved by id"
   );
 });

 it("Get the Navigable id for a browser", async function test_getIdForBrowser() {
   const { initialBrowser, newBrowser, newContext } = testData;

   const invalidValues = [undefined, null, 1, "foo", {}, []];
   invalidValues.forEach(value =>
     is(NavigableManager.getBrowserById(value), null)
   );

   is(
     NavigableManager.getIdForBrowser(newContext),
     null,
     "Requires a browser instance as argument"
   );

   const newBrowserId = NavigableManager.getIdForBrowser(newBrowser);
   Assert.stringMatches(
     NavigableManager.getIdForBrowser(newBrowser),
     uuidRegex,
     "Got a valid uuid for the browser"
   );
   is(
     NavigableManager.getIdForBrowser(newBrowser),
     newBrowserId,
     "For the same browser the identical id is returned"
   );
   isnot(
     NavigableManager.getIdForBrowser(initialBrowser),
     newBrowserId,
     "For a different browser the id is not the same"
   );
 });

 it("Get the Navigable id for a BrowsingContext", async function test_getIdForBrowsingContext() {
   const { newBrowser, newContext, newFrameContexts } = testData;

   const invalidValues = [undefined, null, 1, "foo", {}, []];
   invalidValues.forEach(value =>
     is(NavigableManager.getIdForBrowsingContext(value), null)
   );

   const newContextId = NavigableManager.getIdForBrowsingContext(newContext);
   const newFrameContextIds = newFrameContexts.map(context =>
     NavigableManager.getIdForBrowsingContext(context)
   );

   Assert.stringMatches(
     newContextId,
     uuidRegex,
     "Got a valid uuid for top-level context"
   );
   is(
     NavigableManager.getIdForBrowsingContext(newContext),
     newContextId,
     "Id is always the same for a top-level context"
   );
   is(
     NavigableManager.getIdForBrowsingContext(newContext),
     NavigableManager.getIdForBrowser(newBrowser),
     "Id of a top-level context is equal to the browser id"
   );

   Assert.stringMatches(
     newFrameContextIds[0],
     numberRegex,
     "Got a valid id for a child context"
   );
   is(
     NavigableManager.getIdForBrowsingContext(newFrameContexts[0]),
     newFrameContextIds[0],
     "Id is always the same for a child context"
   );
 });

 it("Get the Navigable for a BrowsingContext", async function test_getNavigableForBrowsingContext() {
   const { newBrowser, newContext, newFrameContexts, newTab } = testData;

   const invalidValues = [undefined, null, 1, "test", {}, [], newBrowser];
   invalidValues.forEach(invalidValue =>
     Assert.throws(
       () => NavigableManager.getNavigableForBrowsingContext(invalidValue),
       /Expected browsingContext to be a CanonicalBrowsingContext/
     )
   );

   is(
     NavigableManager.getNavigableForBrowsingContext(newContext),
     newBrowser,
     "Top-Level context has the content browser as navigable"
   );
   is(
     NavigableManager.getNavigableForBrowsingContext(newFrameContexts[0]),
     newFrameContexts[0],
     "Child context has itself as navigable"
   );

   gBrowser.removeTab(newTab);
 });

 it("Get discarded BrowsingContext by id", async function test_getDiscardedBrowsingContextById() {
   const { newBrowser, newContext, newFrameContexts, newTab } = testData;

   const newContextId = NavigableManager.getIdForBrowsingContext(newContext);
   const newFrameContextIds = newFrameContexts.map(context =>
     NavigableManager.getIdForBrowsingContext(context)
   );

   is(
     NavigableManager.getBrowsingContextById(newContextId),
     newContext,
     "Top context can be retrieved by its id"
   );
   is(
     NavigableManager.getBrowsingContextById(newFrameContextIds[0]),
     newFrameContexts[0],
     "Child context can be retrieved by its id"
   );

   // Remove all the iframes
   await SpecialPowers.spawn(newBrowser, [], async () => {
     const frames = content.document.querySelectorAll("iframe");
     frames.forEach(frame => frame.remove());
   });

   is(
     NavigableManager.getBrowsingContextById(newContextId),
     newContext,
     "Top context can still be retrieved after removing all the frames"
   );
   is(
     NavigableManager.getBrowsingContextById(newFrameContextIds[0]),
     null,
     "Child context can no longer be retrieved by its id after removing all the frames"
   );

   gBrowser.removeTab(newTab);

   is(
     NavigableManager.getBrowsingContextById(newContextId),
     null,
     "Top context can no longer be retrieved by its id after the tab is closed"
   );
 });

 it("Support unloaded browsers", async function test_unloadedBrowser() {
   const { newBrowser, newContext, newTab } = testData;

   const newBrowserId = NavigableManager.getIdForBrowser(newBrowser);
   const newContextId = NavigableManager.getIdForBrowsingContext(newContext);

   await gBrowser.discardBrowser(newTab);

   is(
     NavigableManager.getIdForBrowser(newBrowser),
     newBrowserId,
     "Id for the browser is still available after unloading the tab"
   );
   is(
     NavigableManager.getBrowserById(newBrowserId),
     newBrowser,
     "Unloaded browser can still be retrieved by id"
   );

   is(
     NavigableManager.getIdForBrowsingContext(newContext),
     newContextId,
     "Id for the browsing context is still available after unloading the tab"
   );
   is(
     NavigableManager.getBrowsingContextById(newContextId),
     null,
     "Browsing context can no longer be retrieved after unloading the tab"
   );
   Assert.throws(
     () => NavigableManager.getNavigableForBrowsingContext(newContext),
     /Expected browsingContext to be a CanonicalBrowsingContext/
   );

   // Loading a new page for new browsing contexts
   await loadURL(newBrowser, TEST_URL);

   const newBrowsingContext = newBrowser.browsingContext;

   is(
     NavigableManager.getIdForBrowser(newBrowser),
     newBrowserId,
     "Id for the browser is still the same when navigating after unloading the tab"
   );
   is(
     NavigableManager.getBrowserById(newBrowserId),
     newBrowser,
     "New browser can be retrieved by its id"
   );

   is(
     NavigableManager.getIdForBrowsingContext(newBrowsingContext),
     newContextId,
     "Id for the new top-level context is still the same"
   );
   is(
     NavigableManager.getBrowsingContextById(newContextId),
     newBrowsingContext,
     "Top-level context can be retrieved again"
   );
   is(
     NavigableManager.getNavigableForBrowsingContext(newBrowsingContext),
     newBrowser,
     "The navigable can be retrieved again"
   );
 });

 it("Retrieve id for cross-group opener", async function test_crossGroupOpener() {
   const { newContext, newBrowser, newTab } = testData;

   const newContextId = NavigableManager.getIdForBrowsingContext(newContext);

   await SpecialPowers.spawn(newBrowser, [], async () => {
     content.open("", "_blank", "");
   });

   const browser = gBrowser.selectedBrowser;
   const openerContext = browser.browsingContext.crossGroupOpener;

   isnot(
     browser.browsingContext.crossGroupOpener,
     null,
     "Opened popup window has a cross-group opener"
   );
   is(
     NavigableManager.getIdForBrowsingContext(openerContext),
     newContextId,
     "Id of cross-group opener context is correct"
   );

   // Remove the tab which opened the popup window
   gBrowser.removeTab(newTab);

   is(
     NavigableManager.getIdForBrowsingContext(openerContext),
     newContextId,
     "Id of cross-group opener context is still correct after closing the opener tab"
   );
 });

 it("Start and stop tracking of browsing contexts", async function test_startStopTracking() {
   async function addUnloadedTab(tabBrowser) {
     info(`Open a new tab, navigate, and unload it immediately`);
     const newTab = await addTabAndWaitForNavigated(tabBrowser, TEST_URL);

     const newBrowser = newTab.linkedBrowser;
     const newContext = newBrowser.browsingContext;

     const newFrameContexts = newContext
       .getAllBrowsingContextsInSubtree()
       .filter(context => context.parent);

     info(`Unload the newly opened tab`);
     await tabBrowser.discardBrowser(newTab);

     return {
       newBrowser,
       newContext,
       newFrameContexts,
       newTab,
     };
   }

   // Calling start tracking multiple times doesn't cause failures.
   NavigableManager.startTracking();
   NavigableManager.startTracking();

   {
     // Stop tracking of new browsing contexts
     NavigableManager.stopTracking();

     let { newBrowser, newContext } = await addUnloadedTab(gBrowser);

     Assert.stringMatches(
       NavigableManager.getIdForBrowser(newBrowser),
       uuidRegex,
       "There is always a valid uuid for the browser"
     );
     is(
       NavigableManager.getIdForBrowsingContext(newContext),
       null,
       "There is no id of a temporarily open top-level context"
     );
   }

   // Calling stop tracking multiple times doesn't cause failures.
   NavigableManager.stopTracking();

   // Re-enable tracking
   NavigableManager.startTracking();

   let { newBrowser, newContext } = await addUnloadedTab(gBrowser);

   Assert.stringMatches(
     NavigableManager.getIdForBrowser(newBrowser),
     uuidRegex,
     "Got a valid uuid for the browser"
   );
   Assert.stringMatches(
     NavigableManager.getIdForBrowsingContext(newContext),
     uuidRegex,
     "Got a valid uuid for the top-level context"
   );
 });

 it("Get the Navigable id for a chrome browsing context", async function test_getIdForChromeBrowsingContext() {
   // Get the parent process browsing context (chrome scope)
   const chromeContext = window.browsingContext;

   ok(!chromeContext.isContent, "Chrome context is not a content context");

   const chromeContextId =
     NavigableManager.getIdForBrowsingContext(chromeContext);

   Assert.stringMatches(
     chromeContextId,
     uuidRegex,
     "Got a valid uuid for chrome browsing context"
   );

   is(
     NavigableManager.getIdForBrowsingContext(chromeContext),
     chromeContextId,
     "Id is always the same for the same chrome browsing context"
   );

   const chromeContext2 = BrowsingContext.getFromWindow(
     Services.wm.getMostRecentWindow("navigator:browser")
   );
   is(
     NavigableManager.getIdForBrowsingContext(chromeContext2),
     chromeContextId,
     "Same chrome context returns same id when retrieved differently"
   );
 });

 it("Get chrome browsing context by its Navigable id", async function test_getChromeBrowsingContextById() {
   const chromeContext = BrowsingContext.getFromWindow(window);

   ok(!chromeContext.isContent, "Chrome context is not a content context");

   const chromeContextId =
     NavigableManager.getIdForBrowsingContext(chromeContext);

   is(
     NavigableManager.getBrowsingContextById(chromeContextId),
     chromeContext,
     "Chrome browsing context can be retrieved by its id"
   );
 });

 it("Chrome browsing contexts have different ids than content contexts", async function test_chromeVsContentIds() {
   const { newContext } = testData;
   const chromeContext = BrowsingContext.getFromWindow(window);

   const chromeContextId =
     NavigableManager.getIdForBrowsingContext(chromeContext);
   const contentContextId =
     NavigableManager.getIdForBrowsingContext(newContext);

   Assert.stringMatches(
     chromeContextId,
     uuidRegex,
     "Chrome context has valid uuid"
   );
   Assert.stringMatches(
     contentContextId,
     uuidRegex,
     "Content context has valid uuid"
   );

   isnot(
     chromeContextId,
     contentContextId,
     "Chrome and content contexts have different ids"
   );
 });

 it("Chrome browsing context cleanup on discard", async function test_chromeBrowsingContextDiscard() {
   // Open a new window to get a chrome browsing context we can close
   const newWindow = await BrowserTestUtils.openNewBrowserWindow();
   const newChromeContext = BrowsingContext.getFromWindow(newWindow);

   ok(
     !newChromeContext.isContent,
     "New window's chrome context is not a content context"
   );

   const chromeContextId =
     NavigableManager.getIdForBrowsingContext(newChromeContext);

   Assert.stringMatches(
     chromeContextId,
     uuidRegex,
     "Got a valid uuid for new window's chrome context"
   );

   is(
     NavigableManager.getBrowsingContextById(chromeContextId),
     newChromeContext,
     "Chrome browsing context can be retrieved by id"
   );

   // Close the new window
   await BrowserTestUtils.closeWindow(newWindow);

   is(
     NavigableManager.getBrowsingContextById(chromeContextId),
     null,
     "Discarded chrome browsing context has no navigable id"
   );
 });
});