firefox/browser/base/content/test/outOfProcess/browser_promisefocus.js

// Opens another window and switches focus between them.
add_task(async function test_window_focus() {
  let window2 = await BrowserTestUtils.openNewBrowserWindow();
  ok(!document.hasFocus(), "hasFocus after open second window");
  ok(window2.document.hasFocus(), "hasFocus after open second window");
  is(
    Services.focus.activeWindow,
    window2,
    "activeWindow after open second window"
  );
  is(
    Services.focus.focusedWindow,
    window2,
    "focusedWindow after open second window"
  );

  await SimpleTest.promiseFocus(window);
  ok(document.hasFocus(), "hasFocus after promiseFocus on window");
  ok(!window2.document.hasFocus(), "hasFocus after promiseFocus on window");
  is(
    Services.focus.activeWindow,
    window,
    "activeWindow after promiseFocus on window"
  );
  is(
    Services.focus.focusedWindow,
    window,
    "focusedWindow after promiseFocus on window"
  );

  await SimpleTest.promiseFocus(window2);
  ok(!document.hasFocus(), "hasFocus after promiseFocus on second window");
  ok(
    window2.document.hasFocus(),
    "hasFocus after promiseFocus on second window"
  );
  is(
    Services.focus.activeWindow,
    window2,
    "activeWindow after promiseFocus on second window"
  );
  is(
    Services.focus.focusedWindow,
    window2,
    "focusedWindow after promiseFocus on second window"
  );

  await BrowserTestUtils.closeWindow(window2);

  // If the window is already focused, this should just return.
  await SimpleTest.promiseFocus(window);
  await SimpleTest.promiseFocus(window);
});

// Opens two tabs and ensures that focus can be switched to the browser.
add_task(async function test_tab_focus() {
  let tab1 = await BrowserTestUtils.openNewForegroundTab(
    gBrowser,
    "data:text/html,<input>"
  );

  let tab2 = await BrowserTestUtils.openNewForegroundTab(
    gBrowser,
    "data:text/html,<input>"
  );

  gURLBar.focus();

  await SimpleTest.promiseFocus(tab2.linkedBrowser);
  is(
    document.activeElement,
    tab2.linkedBrowser,
    "Browser is focused after promiseFocus"
  );

  await SpecialPowers.spawn(tab1.linkedBrowser, [], () => {
    Assert.equal(
      Services.focus.activeBrowsingContext,
      null,
      "activeBrowsingContext in child process in hidden tab"
    );
    Assert.equal(
      Services.focus.focusedWindow,
      null,
      "focusedWindow in child process in hidden tab"
    );
    Assert.ok(
      !content.document.hasFocus(),
      "hasFocus in child process in hidden tab"
    );
  });

  await SpecialPowers.spawn(tab2.linkedBrowser, [], () => {
    Assert.equal(
      Services.focus.activeBrowsingContext,
      content.browsingContext,
      "activeBrowsingContext in child process in visible tab"
    );
    Assert.equal(
      Services.focus.focusedWindow,
      content.window,
      "focusedWindow in child process in visible tab"
    );
    Assert.ok(
      content.document.hasFocus(),
      "hasFocus in child process in visible tab"
    );
  });

  BrowserTestUtils.removeTab(tab1);
  BrowserTestUtils.removeTab(tab2);
});

// Opens a document with a nested hierarchy of frames using initChildFrames and
// focuses each child iframe in turn.
add_task(async function test_subframes_focus() {
  let tab = await BrowserTestUtils.openNewForegroundTab(
    gBrowser,
    OOP_BASE_PAGE_URI
  );

  const markup = "<input>";

  let browser = tab.linkedBrowser;
  let browsingContexts = await initChildFrames(browser, markup);

  for (let blurSubframe of [true, false]) {
    for (let index = browsingContexts.length - 1; index >= 0; index--) {
      let bc = browsingContexts[index];

      // Focus each browsing context in turn. Do this twice, once when the window
      // is not already focused, and once when it is already focused.
      for (let step = 0; step < 2; step++) {
        let desc =
          "within child frame " +
          index +
          " step " +
          step +
          " blur subframe " +
          blurSubframe +
          " ";

        info(desc + "start");
        await SimpleTest.promiseFocus(bc, false, blurSubframe);

        let expectedFocusedBC = bc;
        // Becuase we are iterating backwards through the iframes, when we get to a frame
        // that contains the iframe we just tested, focusing it will keep the child
        // iframe focused as well, so we need to account for this when verifying which
        // child iframe is focused. For the root frame (index 0), the iframe nested
        // two items down will actually be focused.
        // If blurSubframe is true however, the iframe focus in the parent will be cleared,
        // so the focused window should be the parent instead.
        if (!blurSubframe) {
          if (index == 0) {
            expectedFocusedBC = browsingContexts[index + 2];
          } else if (index == 3 || index == 1) {
            expectedFocusedBC = browsingContexts[index + 1];
          }
        }
        is(
          Services.focus.focusedContentBrowsingContext,
          expectedFocusedBC,
          desc +
            " focusedContentBrowsingContext" +
            ":: " +
            Services.focus.focusedContentBrowsingContext?.id +
            "," +
            expectedFocusedBC?.id
        );

        // If the processes don't match, then the child iframe is an out-of-process iframe.
        let oop =
          expectedFocusedBC.currentWindowGlobal.osPid !=
          bc.currentWindowGlobal.osPid;
        await SpecialPowers.spawn(
          bc,
          [
            index,
            desc,
            expectedFocusedBC != bc ? expectedFocusedBC : null,
            oop,
          ],
          (num, descChild, childBC, isOop) => {
            Assert.equal(
              Services.focus.activeBrowsingContext,
              content.browsingContext.top,
              descChild + "activeBrowsingContext"
            );
            Assert.ok(
              content.document.hasFocus(),
              descChild + "hasFocus: " + content.browsingContext.id
            );

            // If a child browsing context is expected to be focused, the focusedWindow
            // should be set to that instead and the active element should be an iframe.
            // Otherwise, the focused window should be this window, and the active
            // element should be the document's body element.
            if (childBC) {
              // The frame structure is:
              //    A1
              //      -> B
              //      -> A2
              // where A and B are two processes. The frame A2 starts out focused. When B is
              // focused, A1's focus is updated correctly.

              // In Fission mode, childBC.window returns a non-null proxy even if OOP
              if (isOop) {
                Assert.equal(
                  Services.focus.focusedWindow,
                  null,
                  descChild + "focusedWindow"
                );
                Assert.ok(!childBC.docShell, descChild + "childBC.docShell");
              } else {
                Assert.equal(
                  Services.focus.focusedWindow,
                  childBC.window,
                  descChild + "focusedWindow"
                );
              }
              Assert.equal(
                content.document.activeElement.localName,
                "iframe",
                descChild + "activeElement"
              );
            } else {
              Assert.equal(
                Services.focus.focusedWindow,
                content.window,
                descChild + "focusedWindow"
              );
              Assert.equal(
                content.document.activeElement,
                content.document.body,
                descChild + "activeElement"
              );
            }
          }
        );
      }
    }
  }

  // Focus the top window without blurring the browser.
  await SimpleTest.promiseFocus(window, false, false);
  is(
    document.activeElement.localName,
    "browser",
    "focus after blurring browser blur subframe false"
  );

  // Now, focus the top window, blurring the browser.
  await SimpleTest.promiseFocus(window, false, true);
  is(
    document.activeElement,
    document.body,
    "focus after blurring browser blur subframe true"
  );

  BrowserTestUtils.removeTab(tab);
});