tor-browser

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

browser_595601-restore_hidden.js (4334B)

      1 /* Any copyright is dedicated to the Public Domain.
      2   http://creativecommons.org/publicdomain/zero/1.0/ */
      3 
      4 var windowState = {
      5  windows: [
      6    {
      7      tabs: [
      8        {
      9          entries: [
     10            { url: "http://example.com#1", triggeringPrincipal_base64 },
     11          ],
     12        },
     13        {
     14          entries: [
     15            { url: "http://example.com#2", triggeringPrincipal_base64 },
     16          ],
     17        },
     18        {
     19          entries: [
     20            { url: "http://example.com#3", triggeringPrincipal_base64 },
     21          ],
     22        },
     23        {
     24          entries: [
     25            { url: "http://example.com#4", triggeringPrincipal_base64 },
     26          ],
     27        },
     28        {
     29          entries: [
     30            { url: "http://example.com#5", triggeringPrincipal_base64 },
     31          ],
     32          hidden: true,
     33        },
     34        {
     35          entries: [
     36            { url: "http://example.com#6", triggeringPrincipal_base64 },
     37          ],
     38          hidden: true,
     39        },
     40        {
     41          entries: [
     42            { url: "http://example.com#7", triggeringPrincipal_base64 },
     43          ],
     44          hidden: true,
     45        },
     46        {
     47          entries: [
     48            { url: "http://example.com#8", triggeringPrincipal_base64 },
     49          ],
     50          hidden: true,
     51        },
     52      ],
     53    },
     54  ],
     55 };
     56 
     57 function test() {
     58  waitForExplicitFinish();
     59  requestLongerTimeout(2);
     60 
     61  registerCleanupFunction(function () {
     62    Services.prefs.clearUserPref("browser.sessionstore.restore_hidden_tabs");
     63  });
     64 
     65  // First stage: restoreHiddenTabs = true
     66  // Second stage: restoreHiddenTabs = false
     67  test_loadTabs(true, function () {
     68    test_loadTabs(false, finish);
     69  });
     70 }
     71 
     72 function test_loadTabs(restoreHiddenTabs, callback) {
     73  Services.prefs.setBoolPref(
     74    "browser.sessionstore.restore_hidden_tabs",
     75    restoreHiddenTabs
     76  );
     77 
     78  let expectedTabs = restoreHiddenTabs ? 8 : 4;
     79  let firstProgress = true;
     80 
     81  newWindowWithState(windowState, function (win, needsRestore, isRestoring) {
     82    if (firstProgress) {
     83      firstProgress = false;
     84      is(isRestoring, 3, "restoring 3 tabs concurrently");
     85    } else {
     86      Assert.less(isRestoring, 4, "restoring max. 3 tabs concurrently");
     87    }
     88 
     89    // We're explicity checking for (isRestoring == 1) here because the test
     90    // progress listener is called before the session store one. So when we're
     91    // called with one tab left to restore we know that the last tab has
     92    // finished restoring and will soon be handled by the SS listener.
     93    let tabsNeedingRestore = win.gBrowser.tabs.length - needsRestore;
     94    if (isRestoring == 1 && tabsNeedingRestore == expectedTabs) {
     95      is(win.gBrowser.visibleTabs.length, 4, "only 4 visible tabs");
     96 
     97      TabsProgressListener.uninit();
     98      executeSoon(callback);
     99    }
    100  });
    101 }
    102 
    103 var TabsProgressListener = {
    104  init(win) {
    105    this.window = win;
    106    Services.obs.addObserver(this, "sessionstore-debug-tab-restored");
    107  },
    108 
    109  uninit() {
    110    Services.obs.removeObserver(this, "sessionstore-debug-tab-restored");
    111 
    112    delete this.window;
    113    delete this.callback;
    114  },
    115 
    116  setCallback(callback) {
    117    this.callback = callback;
    118  },
    119 
    120  observe(browser) {
    121    TabsProgressListener.onRestored(browser);
    122  },
    123 
    124  onRestored(browser) {
    125    if (
    126      this.callback &&
    127      ss.getInternalObjectState(browser) == TAB_STATE_RESTORING
    128    ) {
    129      this.callback.apply(null, [this.window].concat(this.countTabs()));
    130    }
    131  },
    132 
    133  countTabs() {
    134    let needsRestore = 0,
    135      isRestoring = 0;
    136 
    137    for (let i = 0; i < this.window.gBrowser.tabs.length; i++) {
    138      let state = ss.getInternalObjectState(
    139        this.window.gBrowser.tabs[i].linkedBrowser
    140      );
    141      if (state == TAB_STATE_RESTORING) {
    142        isRestoring++;
    143      } else if (state == TAB_STATE_NEEDS_RESTORE) {
    144        needsRestore++;
    145      }
    146    }
    147 
    148    return [needsRestore, isRestoring];
    149  },
    150 };
    151 
    152 // ----------
    153 function newWindowWithState(state, callback) {
    154  let opts = "chrome,all,dialog=no,height=800,width=800";
    155  let win = window.openDialog(AppConstants.BROWSER_CHROME_URL, "_blank", opts);
    156 
    157  registerCleanupFunction(() => BrowserTestUtils.closeWindow(win));
    158 
    159  whenWindowLoaded(win, function onWindowLoaded(aWin) {
    160    TabsProgressListener.init(aWin);
    161    TabsProgressListener.setCallback(callback);
    162 
    163    ss.setWindowState(aWin, JSON.stringify(state), true);
    164  });
    165 }