tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

browser_fullscreen-sizemode.js (5712B)

      1 /* Any copyright is dedicated to the Public Domain.
      2   http://creativecommons.org/publicdomain/zero/1.0/ */
      3 
      4 "use strict";
      5 
      6 const isMac = AppConstants.platform == "macosx";
      7 const isWin = AppConstants.platform == "win";
      8 
      9 async function waitForSizeMode(aWindow, aSizeMode) {
     10  await BrowserTestUtils.waitForEvent(aWindow, "sizemodechange", false, () => {
     11    return aWindow.windowState === aSizeMode;
     12  });
     13  const expectedHidden =
     14    aSizeMode == aWindow.STATE_MINIMIZED || aWindow.isFullyOccluded;
     15  if (aWindow.document.hidden != expectedHidden) {
     16    await BrowserTestUtils.waitForEvent(aWindow, "visibilitychange");
     17  }
     18  is(
     19    aWindow.document.hidden,
     20    expectedHidden,
     21    "Should be inactive if minimized or occluded"
     22  );
     23 }
     24 
     25 async function checkSizeModeAndFullscreenState(
     26  aWindow,
     27  aSizeMode,
     28  aFullscreen,
     29  aFullscreenEventShouldHaveFired,
     30  aStepFun
     31 ) {
     32  let promises = [];
     33  if (aWindow.windowState != aSizeMode) {
     34    promises.push(waitForSizeMode(aWindow, aSizeMode));
     35  }
     36  if (aFullscreenEventShouldHaveFired) {
     37    promises.push(
     38      BrowserTestUtils.waitForEvent(
     39        aWindow,
     40        aFullscreen ? "willenterfullscreen" : "willexitfullscreen"
     41      )
     42    );
     43    promises.push(BrowserTestUtils.waitForEvent(aWindow, "fullscreen"));
     44  }
     45 
     46  // Add listener for unexpected event.
     47  let unexpectedEventListener = aEvent => {
     48    ok(false, `should not receive ${aEvent.type} event`);
     49  };
     50  if (aFullscreenEventShouldHaveFired) {
     51    aWindow.addEventListener(
     52      aFullscreen ? "willexitfullscreen" : "willenterfullscreen",
     53      unexpectedEventListener
     54    );
     55  } else {
     56    aWindow.addEventListener("willenterfullscreen", unexpectedEventListener);
     57    aWindow.addEventListener("willexitfullscreen", unexpectedEventListener);
     58    aWindow.addEventListener("fullscreen", unexpectedEventListener);
     59  }
     60 
     61  let eventPromise = Promise.all(promises);
     62  aStepFun();
     63  await eventPromise;
     64 
     65  // Check SizeMode.
     66  is(
     67    aWindow.windowState,
     68    aSizeMode,
     69    "The new sizemode should have the expected value"
     70  );
     71  // Check Fullscreen state.
     72  is(
     73    aWindow.fullScreen,
     74    aFullscreen,
     75    `chrome window should ${aFullscreen ? "be" : "not be"} in fullscreen`
     76  );
     77  is(
     78    aWindow.document.documentElement.hasAttribute("inFullscreen"),
     79    aFullscreen,
     80    `chrome documentElement should ${
     81      aFullscreen ? "have" : "not have"
     82    } inFullscreen attribute`
     83  );
     84 
     85  // Remove listener for unexpected event.
     86  if (aFullscreenEventShouldHaveFired) {
     87    aWindow.removeEventListener(
     88      aFullscreen ? "willexitfullscreen" : "willenterfullscreen",
     89      unexpectedEventListener
     90    );
     91  } else {
     92    aWindow.removeEventListener("willenterfullscreen", unexpectedEventListener);
     93    aWindow.removeEventListener("willexitfullscreen", unexpectedEventListener);
     94    aWindow.removeEventListener("fullscreen", unexpectedEventListener);
     95  }
     96 }
     97 
     98 async function restoreWindowToNormal(aWindow) {
     99  while (aWindow.windowState != aWindow.STATE_NORMAL) {
    100    info(`Try to restore window with state ${aWindow.windowState} to normal`);
    101    let eventPromise = BrowserTestUtils.waitForEvent(aWindow, "sizemodechange");
    102    aWindow.restore();
    103    await eventPromise;
    104    info(`Window is now in state ${aWindow.windowState}`);
    105  }
    106 }
    107 
    108 add_task(async function test_fullscreen_restore() {
    109  let win = await BrowserTestUtils.openNewBrowserWindow();
    110  await restoreWindowToNormal(win);
    111 
    112  info("Enter fullscreen");
    113  await checkSizeModeAndFullscreenState(
    114    win,
    115    win.STATE_FULLSCREEN,
    116    true,
    117    true,
    118    () => {
    119      win.fullScreen = true;
    120    }
    121  );
    122 
    123  info("Restore window");
    124  await checkSizeModeAndFullscreenState(
    125    win,
    126    win.STATE_NORMAL,
    127    false,
    128    true,
    129    () => {
    130      win.restore();
    131    }
    132  );
    133 
    134  await BrowserTestUtils.closeWindow(win);
    135 });
    136 
    137 // This test only enable on Windows because:
    138 // - Test gets intermittent timeout on macOS, see bug 1828848.
    139 // - Restoring a fullscreen window on GTK doesn't return it to the previous
    140 //   sizemode, see bug 1828837.
    141 if (isWin) {
    142  add_task(async function test_maximize_fullscreen_restore() {
    143    let win = await BrowserTestUtils.openNewBrowserWindow();
    144    await restoreWindowToNormal(win);
    145 
    146    info("Maximize window");
    147    await checkSizeModeAndFullscreenState(
    148      win,
    149      win.STATE_MAXIMIZED,
    150      false,
    151      false,
    152      () => {
    153        win.maximize();
    154      }
    155    );
    156 
    157    info("Enter fullscreen");
    158    await checkSizeModeAndFullscreenState(
    159      win,
    160      win.STATE_FULLSCREEN,
    161      true,
    162      true,
    163      () => {
    164        win.fullScreen = true;
    165      }
    166    );
    167 
    168    info("Restore window");
    169    await checkSizeModeAndFullscreenState(
    170      win,
    171      win.STATE_MAXIMIZED,
    172      false,
    173      true,
    174      () => {
    175        win.restore();
    176      }
    177    );
    178 
    179    await BrowserTestUtils.closeWindow(win);
    180  });
    181 }
    182 
    183 // Restoring a minimized window on macOS doesn't return it to the previous
    184 // sizemode, see bug 1828706.
    185 if (!isMac) {
    186  add_task(async function test_fullscreen_minimize_restore() {
    187    let win = await BrowserTestUtils.openNewBrowserWindow();
    188    await restoreWindowToNormal(win);
    189 
    190    info("Enter fullscreen");
    191    await checkSizeModeAndFullscreenState(
    192      win,
    193      win.STATE_FULLSCREEN,
    194      true,
    195      true,
    196      () => {
    197        win.fullScreen = true;
    198      }
    199    );
    200 
    201    info("Minimize window");
    202    await checkSizeModeAndFullscreenState(
    203      win,
    204      win.STATE_MINIMIZED,
    205      true,
    206      false,
    207      () => {
    208        win.minimize();
    209      }
    210    );
    211 
    212    info("Restore window");
    213    await checkSizeModeAndFullscreenState(
    214      win,
    215      win.STATE_FULLSCREEN,
    216      true,
    217      false,
    218      () => {
    219        win.restore();
    220      }
    221    );
    222 
    223    await BrowserTestUtils.closeWindow(win);
    224  });
    225 }